tosca_v2_0

package
v0.22.6 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 14, 2024 License: Apache-2.0 Imports: 21 Imported by: 0

Documentation

Index

Constants

View Source 
const TimestampFormat = "%04d-%02d-%02dT%02d:%02d:%02d%s%s"
View Source 
const TimestampTimezoneFormat = "%s%02d:%02d"

Variables

View Source 
var ConstraintClauseNativeArgumentIndexes = map[string][]int{
	parsing.MetadataContraintPrefix + "equal":            {0},
	parsing.MetadataContraintPrefix + "greater_than":     {0},
	parsing.MetadataContraintPrefix + "greater_or_equal": {0},
	parsing.MetadataContraintPrefix + "less_than":        {0},
	parsing.MetadataContraintPrefix + "less_or_equal":    {0},
	parsing.MetadataContraintPrefix + "in_range":         {0, 1},
	parsing.MetadataContraintPrefix + "valid_values":     {-1},
}
View Source 
var ConstraintClauseScriptlets = map[string]string{
	parsing.MetadataContraintPrefix + "equal":            profiles.GetString(constraintPathPrefix + "equal.js"),
	parsing.MetadataContraintPrefix + "greater_than":     profiles.GetString(constraintPathPrefix + "greater_than.js"),
	parsing.MetadataContraintPrefix + "greater_or_equal": profiles.GetString(constraintPathPrefix + "greater_or_equal.js"),
	parsing.MetadataContraintPrefix + "less_than":        profiles.GetString(constraintPathPrefix + "less_than.js"),
	parsing.MetadataContraintPrefix + "less_or_equal":    profiles.GetString(constraintPathPrefix + "less_or_equal.js"),
	parsing.MetadataContraintPrefix + "in_range":         profiles.GetString(constraintPathPrefix + "in_range.js"),
	parsing.MetadataContraintPrefix + "valid_values":     profiles.GetString(constraintPathPrefix + "valid_values.js"),
	parsing.MetadataContraintPrefix + "length":           profiles.GetString(constraintPathPrefix + "length.js"),
	parsing.MetadataContraintPrefix + "min_length":       profiles.GetString(constraintPathPrefix + "min_length.js"),
	parsing.MetadataContraintPrefix + "max_length":       profiles.GetString(constraintPathPrefix + "max_length.js"),
	parsing.MetadataContraintPrefix + "pattern":          profiles.GetString(constraintPathPrefix + "pattern.js"),
	parsing.MetadataContraintPrefix + "schema":           profiles.GetString(constraintPathPrefix + "schema.js"),
}

Built-in constraint functions

View Source 
var DefaultScriptletNamespace = parsing.NewScriptletNamespace()
View Source 
var FunctionScriptlets = map[string]string{
	parsing.MetadataFunctionPrefix + "concat":               profiles.GetString(functionPathPrefix + "concat.js"),
	parsing.MetadataFunctionPrefix + "join":                 profiles.GetString(functionPathPrefix + "join.js"),
	parsing.MetadataFunctionPrefix + "token":                profiles.GetString(functionPathPrefix + "token.js"),
	parsing.MetadataFunctionPrefix + "get_input":            profiles.GetString(functionPathPrefix + "get_input.js"),
	parsing.MetadataFunctionPrefix + "get_property":         profiles.GetString(functionPathPrefix + "get_property.js"),
	parsing.MetadataFunctionPrefix + "get_attribute":        profiles.GetString(functionPathPrefix + "get_attribute.js"),
	parsing.MetadataFunctionPrefix + "get_operation_output": profiles.GetString(functionPathPrefix + "get_operation_output.js"),
	parsing.MetadataFunctionPrefix + "get_nodes_of_type":    profiles.GetString(functionPathPrefix + "get_nodes_of_type.js"),
	parsing.MetadataFunctionPrefix + "get_artifact":         profiles.GetString(functionPathPrefix + "get_artifact.js"),
	parsing.MetadataFunctionPrefix + "$get_target_name":     profiles.GetString(functionPathPrefix + "$get_target_name.js"),
}
View Source 
var Grammar = parsing.NewGrammar()
View Source 
var ScalarUnitBitrateMeasures = ScalarUnitMeasures{
	"bps":   1,
	"Kbps":  1_000,
	"Kibps": 1024,
	"Mbps":  1_000_000,
	"Mibps": 1048576,
	"Gbps":  1_000_000_000,
	"Gibps": 1073741824,
	"Tbps":  1_000_000_000_000,
	"Tibps": 1099511627776,
	"Bps":   8,
	"KBps":  8_000,
	"KiBps": 8192,
	"MBps":  8_000_000,
	"MiBps": 8388608,
	"GBps":  8_000_000_000,
	"GiBps": 8589934592,
	"TBps":  8_000_000_000_000,
	"TiBps": 8796093022208,
}

Case-sensitive!

View Source 
var ScalarUnitBitrateRE = regexp.MustCompile(
	`^(?P<scalar>[0-9]*\.?[0-9]+(?:e[-+]?[0-9]+)?)\s*` +
		`(?P<unit>bps|Kbps|Kibps|Mbps|Mibps|Gbps|Gibps|Tbps|Tibps|Bps|KBps|KiBps|MBps|MiBps|GBps|GiBps|TBps|TiBps)$`)
View Source 
var ScalarUnitFrequencyMeasures = ScalarUnitMeasures{
	"Hz":  1,
	"kHz": 1_000,
	"MHz": 1_000_000,
	"GHz": 1_000_000_000,
}
View Source 
var ScalarUnitFrequencyRE = regexp.MustCompile(
	`^(?P<scalar>[0-9]*\.?[0-9]+(?:e[-+]?[0-9]+)?)\s*` +
		`(?i)(?P<unit>Hz|kHz|MHz|GHz)$`)
View Source 
var ScalarUnitSizeMeasures = ScalarUnitMeasures{
	"B":   1,
	"kB":  1_000,
	"KiB": 1024,
	"MB":  1_000_000,
	"MiB": 1048576,
	"GB":  1_000_000_000,
	"GiB": 1073741824,
	"TB":  1_000_000_000_000,
	"TiB": 1099511627776,
}
View Source 
var ScalarUnitSizeRE = regexp.MustCompile(
	`^(?P<scalar>[0-9]*\.?[0-9]+(?:e[-+]?[0-9]+)?)\s*` +
		`(?i)(?P<unit>B|kB|KiB|MB|MiB|GB|GiB|TB|TiB)$`)
View Source 
var ScalarUnitTimeMeasures = ScalarUnitMeasures{
	"ns": 0.000_000_001,
	"us": 0.000_001,
	"ms": 0.001,
	"s":  1,
	"m":  60,
	"h":  3600,
	"d":  86400,
}
View Source 
var ScalarUnitTimeRE = regexp.MustCompile(
	`^(?P<scalar>[0-9]*\.?[0-9]+(?:e[-+]?[0-9]+)?)\s*` +
		`(?i)(?P<unit>ns|us|ms|s|m|h|d)$`)
View Source 
var ScalarUnitTypeZeroes = map[ard.TypeName]ard.Value{
	"scalar-unit.size":      int(0),
	"scalar-unit.time":      float64(0.0),
	"scalar-unit.frequency": float64(0.0),
	"scalar-unit.bitrate":   float64(0.0),
}
View Source 
var TimestampLongRE = regexp.MustCompile(
	`^(?P<year>[0-9][0-9][0-9][0-9])-(?P<month>[0-9][0-9]?)-(?P<day>[0-9][0-9]?)` +
		`(?:[Tt]|[ \t]+)` +
		`(?P<hour>[0-9][0-9]?):(?P<minute>[0-9][0-9]):(?P<second>[0-9][0-9])(?:(?P<fraction>\.[0-9]*))?` +
		`(?:(?:[ \t]*)(?:Z|(?P<tzhour>[-+][0-9][0-9]?)(?::(?P<tzminute>[0-9][0-9]))?))?$`)
View Source 
var TimestampShortRE = regexp.MustCompile(`^(?P<year>[0-9][0-9][0-9][0-9])-(?P<month>[0-9][0-9])-(?P<day>[0-9][0-9])$`)
View Source 
var True = true
View Source 
var VersionRE = regexp.MustCompile(
	`^(?P<major>\d+)\.(?P<minor>\d+)(?:\.(?P<fix>\d+)` +
		`(?:(?:\.(?P<qualifier>\w+))(?:-(?P<build>\d+))?)?)?$`)

Functions

func CompareFloat64 

func CompareFloat64(v1 float64, v2 float64) int

func CompareInt64 

func CompareInt64(v1 int64, v2 int64) int

func CompareUint32 

func CompareUint32(v1 uint32, v2 uint32) int

func CompareUint64 

func CompareUint64(v1 uint64, v2 uint64) int

func CopyAndMerge 

func CopyAndMerge(target ard.Value, source ard.Value, copiedNames []string, targets ard.Map) (ard.Value, bool)

func CopyTemplate 

func CopyTemplate(context *parsing.Context)

Implements the "copy" feature for node templates and relationship templates

func GetMapSchemas added in v0.21.0 

func GetMapSchemas(dataType *DataType, dataDefinition DataDefinition) (*Schema, *Schema)

func NewValueMeta added in v0.21.0 

func NewValueMeta(context *parsing.Context, dataType *DataType, dataDefinition DataDefinition, constraintClauses ConstraintClauses) *normal.ValueMeta

func NormalizeFunctionCallArguments 

func NormalizeFunctionCallArguments(functionCall *parsing.FunctionCall, context *parsing.Context)

func ParseFunctionCall added in v0.21.0 

func ParseFunctionCall(context *parsing.Context) bool

func ParseFunctionCalls added in v0.21.0 

func ParseFunctionCalls(context *parsing.Context) bool

func ReadArtifact 

func ReadArtifact(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadArtifactDefinition 

func ReadArtifactDefinition(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadArtifactType 

func ReadArtifactType(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadAttributeDefinition 

func ReadAttributeDefinition(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadAttributeMapping 

func ReadAttributeMapping(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadBytes added in v0.17.0 

func ReadBytes(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadCapabilityAssignment 

func ReadCapabilityAssignment(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadCapabilityDefinition 

func ReadCapabilityDefinition(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadCapabilityFilter 

func ReadCapabilityFilter(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadCapabilityMapping 

func ReadCapabilityMapping(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadCapabilityType 

func ReadCapabilityType(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadConditionClause 

func ReadConditionClause(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadConditionClauseAnd added in v0.19.0 

func ReadConditionClauseAnd(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadConstraintClause 

func ReadConstraintClause(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadDataType 

func ReadDataType(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadEventFilter 

func ReadEventFilter(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadFile added in v0.21.0 

func ReadFile(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadGroup 

func ReadGroup(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadGroupType 

func ReadGroupType(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadImport 

func ReadImport(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadInterfaceAssignment 

func ReadInterfaceAssignment(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadInterfaceDefinition 

func ReadInterfaceDefinition(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadInterfaceImplementation 

func ReadInterfaceImplementation(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadInterfaceMapping 

func ReadInterfaceMapping(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadInterfaceType 

func ReadInterfaceType(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadMetadata 

func ReadMetadata(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadNodeFilter 

func ReadNodeFilter(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadNodeTemplate 

func ReadNodeTemplate(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadNodeType 

func ReadNodeType(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadNotificationAssignment 

func ReadNotificationAssignment(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadNotificationDefinition 

func ReadNotificationDefinition(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadOperationAssignment 

func ReadOperationAssignment(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadOperationDefinition 

func ReadOperationDefinition(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadOutputMapping added in v0.16.0 

func ReadOutputMapping(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadParameterDefinition 

func ReadParameterDefinition(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadPolicy 

func ReadPolicy(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadPolicyType 

func ReadPolicyType(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadPropertyDefinition 

func ReadPropertyDefinition(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadPropertyFilter 

func ReadPropertyFilter(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadPropertyMapping 

func ReadPropertyMapping(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadRange 

func ReadRange(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadRangeEntity 

func ReadRangeEntity(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadRelationshipAssignment 

func ReadRelationshipAssignment(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadRelationshipDefinition 

func ReadRelationshipDefinition(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadRelationshipTemplate 

func ReadRelationshipTemplate(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadRelationshipType 

func ReadRelationshipType(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadRepository 

func ReadRepository(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadRequirementAssignment 

func ReadRequirementAssignment(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadRequirementDefinition 

func ReadRequirementDefinition(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadRequirementMapping 

func ReadRequirementMapping(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadScalarUnitBitrate 

func ReadScalarUnitBitrate(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadScalarUnitFrequency 

func ReadScalarUnitFrequency(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadScalarUnitSize 

func ReadScalarUnitSize(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadScalarUnitTime 

func ReadScalarUnitTime(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadSchema 

func ReadSchema(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadServiceFile added in v0.21.0 

func ReadServiceFile(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadServiceTemplate 

func ReadServiceTemplate(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadSubstitutionMappings 

func ReadSubstitutionMappings(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadTimestamp 

func ReadTimestamp(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadTriggerDefinition 

func ReadTriggerDefinition(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadTriggerDefinitionCondition 

func ReadTriggerDefinitionCondition(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadValue 

func ReadValue(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadVersion 

func ReadVersion(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadWorkflowActivityCallOperation 

func ReadWorkflowActivityCallOperation(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadWorkflowActivityDefinition 

func ReadWorkflowActivityDefinition(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadWorkflowDefinition 

func ReadWorkflowDefinition(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadWorkflowPreconditionDefinition 

func ReadWorkflowPreconditionDefinition(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

func ReadWorkflowStepDefinition 

func ReadWorkflowStepDefinition(context *parsing.Context) parsing.EntityPtr

(parsing.Reader signature)

Types

type Artifact 

type Artifact struct {
	*ArtifactDefinition `name:"artifact"`
}

func NewArtifact 

func NewArtifact(context *parsing.Context) *Artifact

func (*Artifact) Copy 

func (self *Artifact) Copy(definition *ArtifactDefinition)

func (*Artifact) DoRender 

func (self *Artifact) DoRender()

func (*Artifact) Normalize 

func (self *Artifact) Normalize(normalNodeTemplate *normal.NodeTemplate) *normal.Artifact

type ArtifactDefinition 

type ArtifactDefinition struct {
	*Entity `name:"artifact definition"`
	Name    string

	ArtifactTypeName  *string `read:"type"` // mandatory only if cannot be inherited
	Description       *string `read:"description"`
	ArtifactVersion   *string `read:"artifact_version"` // introduced in TOSCA 1.3
	Properties        Values  `read:"properties,Value"` // ERRATUM: ommited in TOSCA 1.0-1.2 (appears in artifact type)
	RepositoryName    *string `read:"repository"`
	File              *string `read:"file"` // mandatory only if cannot be inherited
	DeployPath        *string `read:"deploy_path"`
	ChecksumAlgorithm *string `read:"checksum_algorithm"` // introduced in TOSCA 1.3
	Checksum          *string `read:"checksum"`           // introduced in TOSCA 1.3

	ArtifactType *ArtifactType `lookup:"type,ArtifactTypeName" traverse:"ignore" json:"-" yaml:"-"`
	Repository   *Repository   `lookup:"repository,RepositoryName" traverse:"ignore" json:"-" yaml:"-"`
	// contains filtered or unexported fields
}

func NewArtifactDefinition 

func NewArtifactDefinition(context *parsing.Context) *ArtifactDefinition

func (*ArtifactDefinition) GetExtension 

func (self *ArtifactDefinition) GetExtension() string

func (*ArtifactDefinition) GetKey 

func (self *ArtifactDefinition) GetKey() string

(parsing.Mappable interface)

func (*ArtifactDefinition) GetURL 

func (self *ArtifactDefinition) GetURL(context contextpkg.Context) exturl.URL

func (*ArtifactDefinition) Inherit 

func (self *ArtifactDefinition) Inherit(parentDefinition *ArtifactDefinition)

type ArtifactDefinitions 

type ArtifactDefinitions map[string]*ArtifactDefinition

func (ArtifactDefinitions) Inherit 

func (self ArtifactDefinitions) Inherit(parentDefinitions ArtifactDefinitions)

type ArtifactType 

type ArtifactType struct {
	*Type `name:"artifact type"`

	PropertyDefinitions PropertyDefinitions `read:"properties,PropertyDefinition" inherit:"properties,Parent"`
	MIMEType            *string             `read:"mime_type" inherit:"mime_type,Parent"`
	FileExtension       *[]string           `read:"file_ext" inherit:"file_ext,Parent"`

	Parent *ArtifactType `lookup:"derived_from,ParentName" traverse:"ignore" json:"-" yaml:"-"`
}

func NewArtifactType 

func NewArtifactType(context *parsing.Context) *ArtifactType

func (*ArtifactType) GetParent 

func (self *ArtifactType) GetParent() parsing.EntityPtr

(parsing.Hierarchical interface)

func (*ArtifactType) Inherit 

func (self *ArtifactType) Inherit()

(parsing.Inherits interface)

type ArtifactTypes 

type ArtifactTypes []*ArtifactType

type Artifacts 

type Artifacts map[string]*Artifact

func (Artifacts) Normalize 

func (self Artifacts) Normalize(normalNodeTemplate *normal.NodeTemplate)

func (Artifacts) Render 

func (self Artifacts) Render(definitions ArtifactDefinitions, context *parsing.Context)

type AttributeDefinition 

type AttributeDefinition struct {
	*Entity `name:"attribute definition"`
	Name    string

	Metadata          Metadata          `read:"metadata,Metadata"` // introduced in TOSCA 1.2, but only for properties
	Description       *string           `read:"description"`
	DataTypeName      *string           `read:"type"` // mandatory only if cannot be inherited or discovered
	ConstraintClauses ConstraintClauses `read:"constraints,[]ConstraintClause" traverse:"ignore"`
	KeySchema         *Schema           `read:"key_schema,Schema"`   // introduced in TOSCA 1.3
	EntrySchema       *Schema           `read:"entry_schema,Schema"` // mandatory if list or map
	Default           *Value            `read:"default,Value"`
	Status            *string           `read:"status"`

	DataType *DataType `lookup:"type,DataTypeName" traverse:"ignore" json:"-" yaml:"-"`
	// contains filtered or unexported fields
}

func NewAttributeDefinition 

func NewAttributeDefinition(context *parsing.Context) *AttributeDefinition

func (*AttributeDefinition) GetConstraintClauses added in v0.21.0 

func (self *AttributeDefinition) GetConstraintClauses() ConstraintClauses

(DataDefinition interface)

func (*AttributeDefinition) GetDescription added in v0.21.0 

func (self *AttributeDefinition) GetDescription() string

(DataDefinition interface)

func (*AttributeDefinition) GetEntrySchema added in v0.21.0 

func (self *AttributeDefinition) GetEntrySchema() *Schema

(DataDefinition interface)

func (*AttributeDefinition) GetKey 

func (self *AttributeDefinition) GetKey() string

(parsing.Mappable interface)

func (*AttributeDefinition) GetKeySchema added in v0.21.0 

func (self *AttributeDefinition) GetKeySchema() *Schema

(DataDefinition interface)

func (*AttributeDefinition) GetTypeMetadata added in v0.21.0 

func (self *AttributeDefinition) GetTypeMetadata() Metadata

(DataDefinition interface)

func (*AttributeDefinition) Inherit 

func (self *AttributeDefinition) Inherit(parentDefinition *AttributeDefinition)

func (*AttributeDefinition) Render 

func (self *AttributeDefinition) Render()

(parsing.Renderable interface)

func (*AttributeDefinition) ToValueMeta added in v0.21.0 

func (self *AttributeDefinition) ToValueMeta() *normal.ValueMeta

(DataDefinition interface)

type AttributeDefinitions 

type AttributeDefinitions map[string]*AttributeDefinition

func (AttributeDefinitions) Inherit 

func (self AttributeDefinitions) Inherit(parentDefinitions AttributeDefinitions)

type AttributeMapping 

type AttributeMapping struct {
	*Entity `name:"attribute mapping"`
	Name    string

	NodeTemplateName *string
	AttributeName    *string

	NodeTemplate *NodeTemplate `traverse:"ignore" json:"-" yaml:"-"`
	Attribute    *Value        `traverse:"ignore" json:"-" yaml:"-"`
}

func NewAttributeMapping 

func NewAttributeMapping(context *parsing.Context) *AttributeMapping

func (*AttributeMapping) EnsureRender added in v0.18.0 

func (self *AttributeMapping) EnsureRender()

func (*AttributeMapping) GetKey added in v0.18.0 

func (self *AttributeMapping) GetKey() string

(parsing.Mappable interface)

type AttributeMappings 

type AttributeMappings map[string]*AttributeMapping

func (AttributeMappings) EnsureRender added in v0.18.0 

func (self AttributeMappings) EnsureRender()

type Bytes added in v0.17.0 

type Bytes struct {
	OriginalString string `json:"$originalString" yaml:"$originalString"`

	Bytes []byte `json:"bytes" yaml:"bytes"`
}

type CapabilityAssignment 

type CapabilityAssignment struct {
	*Entity `name:"capability"`
	Name    string

	Properties  Values       `read:"properties,Value"`
	Attributes  Values       `read:"attributes,AttributeValue"`
	Occurrences *RangeEntity `read:"occurrences,RangeEntity"` // introduced in TOSCA 1.3
}

func NewCapabilityAssignment 

func NewCapabilityAssignment(context *parsing.Context) *CapabilityAssignment

func (*CapabilityAssignment) GetDefinition 

func (self *CapabilityAssignment) GetDefinition(nodeTemplate *NodeTemplate) (*CapabilityDefinition, bool)

func (*CapabilityAssignment) GetKey 

func (self *CapabilityAssignment) GetKey() string

(parsing.Mappable interface)

func (*CapabilityAssignment) Normalize 

func (self *CapabilityAssignment) Normalize(normalNodeTemplate *normal.NodeTemplate, definition *CapabilityDefinition) *normal.Capability

func (*CapabilityAssignment) Render 

func (self *CapabilityAssignment) Render(definition *CapabilityDefinition)

type CapabilityAssignments 

type CapabilityAssignments map[string]*CapabilityAssignment

func (CapabilityAssignments) Normalize 

func (self CapabilityAssignments) Normalize(nodeTemplate *NodeTemplate, normalNodeTemplate *normal.NodeTemplate)

func (CapabilityAssignments) Render 

func (self CapabilityAssignments) Render(definitions CapabilityDefinitions, context *parsing.Context)

type CapabilityDefinition 

type CapabilityDefinition struct {
	*Entity `name:"capability definition"`
	Name    string

	Description              *string              `read:"description"`
	CapabilityTypeName       *string              `read:"type"` // mandatory only if cannot be inherited
	PropertyDefinitions      PropertyDefinitions  `read:"properties,PropertyDefinition" inherit:"properties,CapabilityType"`
	AttributeDefinitions     AttributeDefinitions `read:"attributes,AttributeDefinition" inherit:"attributes,CapabilityType"`
	ValidSourceNodeTypeNames *[]string            `read:"valid_source_types" inherit:"valid_source_types,CapabilityType"`
	Occurrences              *RangeEntity         `read:"occurrences,RangeEntity"`

	CapabilityType       *CapabilityType `lookup:"type,CapabilityTypeName" traverse:"ignore" json:"-" yaml:"-"`
	ValidSourceNodeTypes NodeTypes       `lookup:"valid_source_types,ValidSourceNodeTypeNames" traverse:"ignore" json:"-" yaml:"-"`
	// contains filtered or unexported fields
}

func NewCapabilityDefinition 

func NewCapabilityDefinition(context *parsing.Context) *CapabilityDefinition

func (*CapabilityDefinition) GetKey 

func (self *CapabilityDefinition) GetKey() string

(parsing.Mappable interface)

func (*CapabilityDefinition) Inherit 

func (self *CapabilityDefinition) Inherit(parentDefinition *CapabilityDefinition)

func (*CapabilityDefinition) Render 

func (self *CapabilityDefinition) Render()

(parsing.Renderable interface)

type CapabilityDefinitions 

type CapabilityDefinitions map[string]*CapabilityDefinition

func (CapabilityDefinitions) Inherit 

func (self CapabilityDefinitions) Inherit(parentDefinitions CapabilityDefinitions)

type CapabilityFilter 

type CapabilityFilter struct {
	*Entity `name:"capability filter"`
	Name    string // name or type name

	PropertyFilters PropertyFilters `read:"properties,{}PropertyFilter"`
}

func NewCapabilityFilter 

func NewCapabilityFilter(context *parsing.Context) *CapabilityFilter

func (CapabilityFilter) Normalize 

func (self CapabilityFilter) Normalize(normalRequirement *normal.Requirement) normal.FunctionCallMap

type CapabilityFilters 

type CapabilityFilters []*CapabilityFilter

func (CapabilityFilters) Normalize 

func (self CapabilityFilters) Normalize(normalRequirement *normal.Requirement)

type CapabilityMapping 

type CapabilityMapping struct {
	*Entity `name:"capability mapping"`
	Name    string

	NodeTemplateName *string
	CapabilityName   *string

	NodeTemplate *NodeTemplate         `traverse:"ignore" json:"-" yaml:"-"`
	Capability   *CapabilityAssignment `traverse:"ignore" json:"-" yaml:"-"`
}

func NewCapabilityMapping 

func NewCapabilityMapping(context *parsing.Context) *CapabilityMapping

func (*CapabilityMapping) GetCapabilityDefinition added in v0.18.0 

func (self *CapabilityMapping) GetCapabilityDefinition() (*CapabilityDefinition, bool)

func (*CapabilityMapping) GetKey added in v0.18.0 

func (self *CapabilityMapping) GetKey() string

(parsing.Mappable interface)

func (*CapabilityMapping) Render 

func (self *CapabilityMapping) Render()

(parsing.Renderable interface)

type CapabilityMappings 

type CapabilityMappings map[string]*CapabilityMapping

type CapabilityType 

type CapabilityType struct {
	*Type `name:"capability type"`

	PropertyDefinitions      PropertyDefinitions  `read:"properties,PropertyDefinition" inherit:"properties,Parent"`
	AttributeDefinitions     AttributeDefinitions `read:"attributes,AttributeDefinition" inherit:"attributes,Parent"`
	ValidSourceNodeTypeNames *[]string            `read:"valid_source_types" inherit:"valid_source_types,Parent"`

	Parent               *CapabilityType `lookup:"derived_from,ParentName" traverse:"ignore" json:"-" yaml:"-"`
	ValidSourceNodeTypes NodeTypes       `lookup:"valid_source_types,ValidSourceNodeTypeNames" inherit:"valid_source_types,Parent" traverse:"ignore" json:"-" yaml:"-"`
}

func NewCapabilityType 

func NewCapabilityType(context *parsing.Context) *CapabilityType

func (*CapabilityType) GetParent 

func (self *CapabilityType) GetParent() parsing.EntityPtr

(parsing.Hierarchical interface)

func (*CapabilityType) Inherit 

func (self *CapabilityType) Inherit()

(parsing.Inherits interface)

type CapabilityTypes 

type CapabilityTypes []*CapabilityType

type ConditionClause 

type ConditionClause struct {
	*Entity `name:"condition clause"`

	// Either an assertion definition (attribute with constraints)
	AttributeName     *string
	ConstraintClauses ConstraintClauses

	// Or one or more child condition clauses
	Operator         *string
	ConditionClauses []*ConditionClause
}

func NewConditionClause 

func NewConditionClause(context *parsing.Context) *ConditionClause

type ConstraintClause 

type ConstraintClause struct {
	*Entity `name:"constraint clause"`

	Operator              string
	Arguments             ard.List
	NativeArgumentIndexes []int
	DataType              *DataType      `traverse:"ignore" json:"-" yaml:"-"` // TODO: unncessary, this entity should never be traversed
	Definition            DataDefinition `traverse:"ignore" json:"-" yaml:"-"`
}

func NewConstraintClause 

func NewConstraintClause(context *parsing.Context) *ConstraintClause

func (*ConstraintClause) IsNativeArgument 

func (self *ConstraintClause) IsNativeArgument(index int) bool

func (*ConstraintClause) ToFunctionCall 

func (self *ConstraintClause) ToFunctionCall(context *parsing.Context, strict bool) *parsing.FunctionCall

type ConstraintClauses 

type ConstraintClauses []*ConstraintClause

func (ConstraintClauses) AddToMeta added in v0.21.0 

func (self ConstraintClauses) AddToMeta(context *parsing.Context, normalValueMeta *normal.ValueMeta)

func (ConstraintClauses) Append 

func (self ConstraintClauses) Append(constraints ConstraintClauses) ConstraintClauses

func (ConstraintClauses) Normalize 

func (self ConstraintClauses) Normalize(context *parsing.Context) normal.FunctionCalls

type DataDefinition added in v0.21.0 

type DataDefinition interface {
	ToValueMeta() *normal.ValueMeta
	GetDescription() string
	GetTypeMetadata() Metadata
	GetConstraintClauses() ConstraintClauses
	GetKeySchema() *Schema
	GetEntrySchema() *Schema
}

type DataType 

type DataType struct {
	*Type `name:"data type"`

	PropertyDefinitions PropertyDefinitions `read:"properties,PropertyDefinition" inherit:"properties,Parent"`
	ConstraintClauses   ConstraintClauses   `read:"constraints,[]ConstraintClause" traverse:"ignore"`
	KeySchema           *Schema             `read:"key_schema,Schema"`   // introduced in TOSCA 1.3
	EntrySchema         *Schema             `read:"entry_schema,Schema"` // introduced in TOSCA 1.3

	Parent *DataType `lookup:"derived_from,ParentName" traverse:"ignore" json:"-" yaml:"-"`
}

func LookupDataType added in v0.21.0 

func LookupDataType(context *parsing.Context, name string) (*DataType, bool)

func NewDataType 

func NewDataType(context *parsing.Context) *DataType

func (*DataType) CompleteData added in v0.21.0 

func (self *DataType) CompleteData(context *parsing.Context)

Note that this may change the data (if it's a map), but that should be fine, because we intend for the data to be complete. For the same reason, this action is idempotent (subsequent calls with the same data will not have an effect).

func (*DataType) GetInternal 

func (self *DataType) GetInternal() *DataTypeInternal

func (*DataType) GetInternalTypeName 

func (self *DataType) GetInternalTypeName() (ard.TypeName, bool)

func (*DataType) GetParent 

func (self *DataType) GetParent() parsing.EntityPtr

(parsing.Hierarchical interface)

func (*DataType) Inherit 

func (self *DataType) Inherit()

(parsing.Inherits interface)

func (*DataType) NewValueMeta added in v0.21.0 

func (self *DataType) NewValueMeta() *normal.ValueMeta

func (*DataType) Render 

func (self *DataType) Render()

(parsing.Renderable interface)

type DataTypeInternal added in v0.21.0 

type DataTypeInternal struct {
	Name      ard.TypeName
	Validator ard.TypeValidator
	Reader    parsing.Reader
}

type DataTypes 

type DataTypes []*DataType

type Entity 

type Entity struct {
	Context *parsing.Context `traverse:"ignore" json:"-" yaml:"-"`
	// contains filtered or unexported fields
}

func NewEntity 

func NewEntity(context *parsing.Context) *Entity

func (*Entity) GetContext 

func (self *Entity) GetContext() *parsing.Context

(parsing.Contextual interface)

type EventFilter 

type EventFilter struct {
	*Entity `name:"event filter" json:"-" yaml:"-"`

	NodeTemplateNameOrTypeName *string `read:"node"`
	RequirementName            *string `read:"requirement"`
	CapabilityName             *string `read:"capability"`

	NodeTemplate *NodeTemplate `lookup:"node,NodeTemplateNameOrTypeName" traverse:"ignore" json:"-" yaml:"-"`
	NodeType     *NodeType     `lookup:"node,NodeTemplateNameOrTypeName" traverse:"ignore" json:"-" yaml:"-"`
}

func NewEventFilter 

func NewEventFilter(context *parsing.Context) *EventFilter

type File added in v0.21.0 

type File struct {
	*Entity `name:"file"`

	ToscaDefinitionsVersion *string           `read:"tosca_definitions_version" mandatory:""`
	Profile                 *string           `read:"profile"` // introduced in TOSCA 1.2 as "namespace", renamed in TOSCA 2.0
	Metadata                Metadata          `read:"metadata,!Metadata"`
	Description             *string           `read:"description"`
	Repositories            Repositories      `read:"repositories,Repository"`
	Imports                 Imports           `read:"imports,[]Import"`
	ArtifactTypes           ArtifactTypes     `read:"artifact_types,ArtifactType" hierarchy:""`
	CapabilityTypes         CapabilityTypes   `read:"capability_types,CapabilityType" hierarchy:""`
	DataTypes               DataTypes         `read:"data_types,DataType" hierarchy:""`
	GroupTypes              GroupTypes        `read:"group_types,GroupType" hierarchy:""`
	InterfaceTypes          InterfaceTypes    `read:"interface_types,InterfaceType" hierarchy:""`
	NodeTypes               NodeTypes         `read:"node_types,NodeType" hierarchy:""`
	PolicyTypes             PolicyTypes       `read:"policy_types,PolicyType" hierarchy:""`
	RelationshipTypes       RelationshipTypes `read:"relationship_types,RelationshipType" hierarchy:""`
}

func NewFile added in v0.21.0 

func NewFile(context *parsing.Context) *File

func (*File) GetImportSpecs added in v0.21.0 

func (self *File) GetImportSpecs() []*parsing.ImportSpec

(parsing.Importer interface)

func (*File) Normalize added in v0.21.0 

func (self *File) Normalize(normalServiceTemplate *normal.ServiceTemplate)

type Group 

type Group struct {
	*Entity `name:"group"`
	Name    string `namespace:""`

	GroupTypeName           *string              `read:"type" mandatory:""`
	Metadata                Metadata             `read:"metadata,Metadata"` // introduced in TOSCA 1.1
	Description             *string              `read:"description"`
	Properties              Values               `read:"properties,Value"`
	Interfaces              InterfaceAssignments // removed in TOSCA 1.3
	MemberNodeTemplateNames *[]string            `read:"members"`

	GroupType           *GroupType      `lookup:"type,GroupTypeName" traverse:"ignore" json:"-" yaml:"-"`
	MemberNodeTemplates []*NodeTemplate `lookup:"members,MemberNodeTemplateNames" traverse:"ignore" json:"-" yaml:"-"`
}

func NewGroup 

func NewGroup(context *parsing.Context) *Group

func (*Group) Normalize 

func (self *Group) Normalize(normalServiceTemplate *normal.ServiceTemplate) *normal.Group

func (*Group) Render 

func (self *Group) Render()

(parsing.Renderable interface)

type GroupType 

type GroupType struct {
	*Type `name:"group type"`

	PropertyDefinitions    PropertyDefinitions    `read:"properties,PropertyDefinition" inherit:"properties,Parent"`
	CapabilityDefinitions  CapabilityDefinitions  `read:"capabilities,CapabilityDefinition" inherit:"capabilities,Parent"`
	RequirementDefinitions RequirementDefinitions `read:"requirements,{}RequirementDefinition" inherit:"requirements,Parent"` // sequenced list, but we read it into map
	InterfaceDefinitions   InterfaceDefinitions   `inherit:"interfaces,Parent"`                                               // removed in TOSCA 1.3
	MemberNodeTypeNames    *[]string              `read:"members" inherit:"members,Parent"`

	Parent          *GroupType `lookup:"derived_from,ParentName" inherit:"members,Parent" traverse:"ignore" json:"-" yaml:"-"`
	MemberNodeTypes NodeTypes  `lookup:"members,MemberNodeTypeNames" inherit:"members,Parent" traverse:"ignore" json:"-" yaml:"-"`
}

func NewGroupType 

func NewGroupType(context *parsing.Context) *GroupType

func (*GroupType) GetParent 

func (self *GroupType) GetParent() parsing.EntityPtr

(parsing.Hierarchical interface)

func (*GroupType) Inherit 

func (self *GroupType) Inherit()

(parsing.Inherits interface)

func (*GroupType) Render 

func (self *GroupType) Render()

(parsing.Renderable interface)

type GroupTypes 

type GroupTypes []*GroupType

func (GroupTypes) IsCompatible 

func (self GroupTypes) IsCompatible(groupType *GroupType) bool

func (GroupTypes) ValidateSubset 

func (self GroupTypes) ValidateSubset(subset GroupTypes, context *parsing.Context) bool

type Groups 

type Groups []*Group

func (Groups) Normalize 

func (self Groups) Normalize(normalServiceTemplate *normal.ServiceTemplate)

type HasComparer 

type HasComparer interface {
	SetComparer(comparer string)
}

type Import 

type Import struct {
	*Entity `name:"import" json:"-" yaml:"-"`

	URL            *string `read:"url" mandatory:""` // renamed in TOSCA 2.0
	RepositoryName *string `read:"repository"`
	Namespace      *string `read:"namespace"` // renamed in TOSCA 2.0
	NamespaceURI   *string /// removed in TOSCA 2.0

	Repository *Repository `lookup:"repository,RepositoryName" traverse:"ignore" json:"-" yaml:"-"`
}

func NewImport 

func NewImport(context *parsing.Context) *Import

func (*Import) NewImportSpec 

func (self *Import) NewImportSpec(unit *File) (*parsing.ImportSpec, bool)

type Imports 

type Imports []*Import

type InterfaceAssignment 

type InterfaceAssignment struct {
	*Entity `name:"interface" json:"-" yaml:"-"`
	Name    string

	Inputs          Values                  `read:"inputs,Value"`
	Operations      OperationAssignments    `read:"operations,OperationAssignment"`       // keyword since TOSCA 1.3
	Notifications   NotificationAssignments `read:"notifications,NotificationAssignment"` // introduced in TOSCA 1.3
	ExtraOperations OperationAssignments    `json:"-" yaml:"-"`
}

func NewInterfaceAssignment 

func NewInterfaceAssignment(context *parsing.Context) *InterfaceAssignment

func (*InterfaceAssignment) GetDefinitionForGroup 

func (self *InterfaceAssignment) GetDefinitionForGroup(group *Group) (*InterfaceDefinition, bool)

func (*InterfaceAssignment) GetDefinitionForNodeTemplate 

func (self *InterfaceAssignment) GetDefinitionForNodeTemplate(nodeTemplate *NodeTemplate) (*InterfaceDefinition, bool)

func (*InterfaceAssignment) GetDefinitionForRelationship 

func (self *InterfaceAssignment) GetDefinitionForRelationship(relationship *RelationshipAssignment, relationshipDefinition *RelationshipDefinition) (*InterfaceDefinition, bool)

func (*InterfaceAssignment) GetKey 

func (self *InterfaceAssignment) GetKey() string

(parsing.Mappable interface)

func (*InterfaceAssignment) Normalize 

func (self *InterfaceAssignment) Normalize(normalInterface *normal.Interface, definition *InterfaceDefinition)

func (*InterfaceAssignment) RenderForGroup added in v0.18.0 

func (self *InterfaceAssignment) RenderForGroup(definition *InterfaceDefinition)

func (*InterfaceAssignment) RenderForNodeType added in v0.21.0 

func (self *InterfaceAssignment) RenderForNodeType(nodeType *NodeType, definition *InterfaceDefinition)

func (*InterfaceAssignment) RenderForRelationshipType added in v0.21.0 

func (self *InterfaceAssignment) RenderForRelationshipType(relationshipType *RelationshipType, definition *InterfaceDefinition, sourceNodeTemplate *NodeTemplate)

type InterfaceAssignments 

type InterfaceAssignments map[string]*InterfaceAssignment

func (InterfaceAssignments) CopyUnassigned 

func (self InterfaceAssignments) CopyUnassigned(assignments InterfaceAssignments)

func (InterfaceAssignments) NormalizeForGroup 

func (self InterfaceAssignments) NormalizeForGroup(group *Group, normalGroup *normal.Group)

func (InterfaceAssignments) NormalizeForNodeTemplate 

func (self InterfaceAssignments) NormalizeForNodeTemplate(nodeTemplate *NodeTemplate, normalNodeTemplate *normal.NodeTemplate)

func (InterfaceAssignments) NormalizeForRelationship 

func (self InterfaceAssignments) NormalizeForRelationship(relationship *RelationshipAssignment, relationshipDefinition *RelationshipDefinition, normalRelationship *normal.Relationship)

func (InterfaceAssignments) RenderForGroup added in v0.18.0 

func (self InterfaceAssignments) RenderForGroup(definitions InterfaceDefinitions, context *parsing.Context)

func (InterfaceAssignments) RenderForNodeType added in v0.21.0 

func (self InterfaceAssignments) RenderForNodeType(nodeType *NodeType, context *parsing.Context)

func (InterfaceAssignments) RenderForRelationshipType added in v0.21.0 

func (self InterfaceAssignments) RenderForRelationshipType(relationshipType *RelationshipType, definitions InterfaceDefinitions, sourceNodeTemplate *NodeTemplate, context *parsing.Context)

type InterfaceDefinition 

type InterfaceDefinition struct {
	*Entity `name:"interface definition" json:"-" yaml:"-"`
	Name    string

	InterfaceTypeName         *string                 `read:"type"` // mandatory only if cannot be inherited
	InputDefinitions          ParameterDefinitions    `read:"inputs,ParameterDefinition" inherit:"inputs,InterfaceType"`
	OperationDefinitions      OperationDefinitions    `read:"operations,OperationDefinition" inherit:"operations,InterfaceType"`          // keyword since TOSCA 1.3
	NotificationDefinitions   NotificationDefinitions `read:"notifications,NotificationDefinition" inherit:"notifications,InterfaceType"` // introduced in TOSCA 1.3
	ExtraOperationDefinitions OperationDefinitions    `json:"-" yaml:"-"`

	InterfaceType *InterfaceType `lookup:"type,InterfaceTypeName" traverse:"ignore" json:"-" yaml:"-"`
	// contains filtered or unexported fields
}

func NewInterfaceDefinition 

func NewInterfaceDefinition(context *parsing.Context) *InterfaceDefinition

func (*InterfaceDefinition) GetKey 

func (self *InterfaceDefinition) GetKey() string

(parsing.Mappable interface)

func (*InterfaceDefinition) Inherit 

func (self *InterfaceDefinition) Inherit(parentDefinition *InterfaceDefinition)

func (*InterfaceDefinition) Render 

func (self *InterfaceDefinition) Render()

(parsing.Renderable interface)

type InterfaceDefinitions 

type InterfaceDefinitions map[string]*InterfaceDefinition

func (InterfaceDefinitions) Inherit 

func (self InterfaceDefinitions) Inherit(parentDefinitions InterfaceDefinitions)

type InterfaceImplementation 

type InterfaceImplementation struct {
	*Entity `name:"interface implementation"`

	Primary       *string   `read:"primary"`
	Dependencies  *[]string `read:"dependencies"`
	Timeout       *int64    `read:"timeout"`        // introduced in TOSCA 1.2
	OperationHost *string   `read:"operation_host"` // introduced in TOSCA 1.2
}

func NewInterfaceImplementation 

func NewInterfaceImplementation(context *parsing.Context) *InterfaceImplementation

func (*InterfaceImplementation) NormalizeNotification 

func (self *InterfaceImplementation) NormalizeNotification(normalNotification *normal.Notification)

func (*InterfaceImplementation) NormalizeOperation 

func (self *InterfaceImplementation) NormalizeOperation(normalOperation *normal.Operation)

func (*InterfaceImplementation) Render 

func (self *InterfaceImplementation) Render(definition *InterfaceImplementation)

type InterfaceMapping 

type InterfaceMapping struct {
	*Entity `name:"interface mapping"`
	Name    string

	NodeTemplateName *string
	InterfaceName    *string

	NodeTemplate *NodeTemplate        `traverse:"ignore" json:"-" yaml:"-"`
	Interface    *InterfaceAssignment `traverse:"ignore" json:"-" yaml:"-"`
}

func NewInterfaceMapping 

func NewInterfaceMapping(context *parsing.Context) *InterfaceMapping

func (*InterfaceMapping) GetInterfaceDefinition added in v0.18.0 

func (self *InterfaceMapping) GetInterfaceDefinition() (*InterfaceDefinition, bool)

func (*InterfaceMapping) GetKey added in v0.18.0 

func (self *InterfaceMapping) GetKey() string

(parsing.Mappable interface)

func (*InterfaceMapping) Render 

func (self *InterfaceMapping) Render()

(parsing.Renderable interface)

type InterfaceMappings 

type InterfaceMappings map[string]*InterfaceMapping

type InterfaceType 

type InterfaceType struct {
	*Type `name:"interface type"`

	InputDefinitions          ParameterDefinitions    `read:"inputs,ParameterDefinition" inherit:"inputs,Parent"`
	OperationDefinitions      OperationDefinitions    `read:"operations,OperationDefinition" inherit:"operations,Parent"`
	NotificationDefinitions   NotificationDefinitions `read:"notifications,NotificationDefinition" inherit:"notifications,Parent"` // introduced in TOSCA 1.3
	ExtraOperationDefinitions OperationDefinitions    `json:"-" yaml:"-"`

	Parent *InterfaceType `lookup:"derived_from,ParentName" traverse:"ignore" json:"-" yaml:"-"`
}

func NewInterfaceType 

func NewInterfaceType(context *parsing.Context) *InterfaceType

func (*InterfaceType) GetParent 

func (self *InterfaceType) GetParent() parsing.EntityPtr

(parsing.Hierarchical interface)

func (*InterfaceType) Inherit 

func (self *InterfaceType) Inherit()

(parsing.Inherits interface)

type InterfaceTypes 

type InterfaceTypes []*InterfaceType

type Metadata 

type Metadata map[string]string

type NodeFilter 

type NodeFilter struct {
	*Entity `name:"node filter"`

	PropertyFilters   PropertyFilters   `read:"properties,{}PropertyFilter"`
	CapabilityFilters CapabilityFilters `read:"capabilities,{}CapabilityFilter"`
}

func NewNodeFilter 

func NewNodeFilter(context *parsing.Context) *NodeFilter

func (*NodeFilter) Normalize 

func (self *NodeFilter) Normalize(normalRequirement *normal.Requirement)

type NodeTemplate 

type NodeTemplate struct {
	*Entity `name:"node template"`
	Name    string `namespace:""`

	Directives                   *[]string              `read:"directives"`
	CopyNodeTemplateName         *string                `read:"copy"`
	NodeTypeName                 *string                `read:"type" mandatory:""`
	Metadata                     Metadata               `read:"metadata,Metadata"` // introduced in TOSCA 1.1
	Description                  *string                `read:"description"`
	Properties                   Values                 `read:"properties,Value"`
	Attributes                   Values                 `read:"attributes,AttributeValue"`
	Capabilities                 CapabilityAssignments  `read:"capabilities,CapabilityAssignment"`
	Requirements                 RequirementAssignments `read:"requirements,{}RequirementAssignment"`
	RequirementTargetsNodeFilter *NodeFilter            `read:"node_filter,NodeFilter"`
	Interfaces                   InterfaceAssignments   `read:"interfaces,InterfaceAssignment"`
	Artifacts                    Artifacts              `read:"artifacts,Artifact"`

	CopyNodeTemplate *NodeTemplate `lookup:"copy,CopyNodeTemplateName" traverse:"ignore" json:"-" yaml:"-"`
	NodeType         *NodeType     `lookup:"type,NodeTypeName" traverse:"ignore" json:"-" yaml:"-"`
}

func NewNodeTemplate 

func NewNodeTemplate(context *parsing.Context) *NodeTemplate

func (*NodeTemplate) Normalize 

func (self *NodeTemplate) Normalize(normalServiceTemplate *normal.ServiceTemplate) *normal.NodeTemplate

func (*NodeTemplate) PreRead 

func (self *NodeTemplate) PreRead()

(parsing.PreReadable interface)

func (*NodeTemplate) Render 

func (self *NodeTemplate) Render()

(parsing.Renderable interface)

type NodeTemplates 

type NodeTemplates []*NodeTemplate

func (NodeTemplates) Normalize 

func (self NodeTemplates) Normalize(normalServiceTemplate *normal.ServiceTemplate)

type NodeType 

type NodeType struct {
	*Type `name:"node type"`

	PropertyDefinitions    PropertyDefinitions    `read:"properties,PropertyDefinition" inherit:"properties,Parent"`
	AttributeDefinitions   AttributeDefinitions   `read:"attributes,AttributeDefinition" inherit:"attributes,Parent"`
	CapabilityDefinitions  CapabilityDefinitions  `read:"capabilities,CapabilityDefinition" inherit:"capabilities,Parent"`
	RequirementDefinitions RequirementDefinitions `read:"requirements,{}RequirementDefinition" inherit:"requirements,Parent"` // sequenced list, but we read it into map
	InterfaceDefinitions   InterfaceDefinitions   `read:"interfaces,InterfaceDefinition" inherit:"interfaces,Parent"`
	ArtifactDefinitions    ArtifactDefinitions    `read:"artifacts,ArtifactDefinition" inherit:"artifacts,Parent"`

	Parent *NodeType `lookup:"derived_from,ParentName" traverse:"ignore" json:"-" yaml:"-"`
}

func NewNodeType 

func NewNodeType(context *parsing.Context) *NodeType

func (*NodeType) GetParent 

func (self *NodeType) GetParent() parsing.EntityPtr

(parsing.Hierarchical interface)

func (*NodeType) Inherit 

func (self *NodeType) Inherit()

(parsing.Inherits interface)

type NodeTypes 

type NodeTypes []*NodeType

func (NodeTypes) IsCompatible 

func (self NodeTypes) IsCompatible(nodeType *NodeType) bool

func (NodeTypes) ValidateSubset 

func (self NodeTypes) ValidateSubset(subset NodeTypes, context *parsing.Context) bool

type NotificationAssignment 

type NotificationAssignment struct {
	*Entity `name:"notification"`
	Name    string

	Description    *string                  `read:"description"`
	Implementation *InterfaceImplementation `read:"implementation,InterfaceImplementation"`
	Outputs        OutputMappings           `read:"outputs,OutputMapping"`
}

func NewNotificationAssignment 

func NewNotificationAssignment(context *parsing.Context) *NotificationAssignment

func (*NotificationAssignment) GetKey 

func (self *NotificationAssignment) GetKey() string

(parsing.Mappable interface)

func (*NotificationAssignment) Normalize 

func (self *NotificationAssignment) Normalize(normalInterface *normal.Interface) *normal.Notification

type NotificationAssignments 

type NotificationAssignments map[string]*NotificationAssignment

func (NotificationAssignments) CopyUnassigned 

func (self NotificationAssignments) CopyUnassigned(assignments NotificationAssignments)

func (NotificationAssignments) Normalize 

func (self NotificationAssignments) Normalize(normalInterface *normal.Interface)

func (NotificationAssignments) RenderForGroup added in v0.18.0 

func (self NotificationAssignments) RenderForGroup(definitions NotificationDefinitions, context *parsing.Context)

func (NotificationAssignments) RenderForNodeType added in v0.21.0 

func (self NotificationAssignments) RenderForNodeType(nodeType *NodeType, definitions NotificationDefinitions, context *parsing.Context)

func (NotificationAssignments) RenderForRelationshipType added in v0.21.0 

func (self NotificationAssignments) RenderForRelationshipType(relationshipType *RelationshipType, definitions NotificationDefinitions, sourceNodeTemplate *NodeTemplate, context *parsing.Context)

type NotificationDefinition 

type NotificationDefinition struct {
	*Entity `name:"notification definition"`
	Name    string

	Description    *string                  `read:"description"`
	Implementation *InterfaceImplementation `read:"implementation,InterfaceImplementation"`
	Outputs        OutputMappings           `read:"outputs,OutputMapping"`
}

func NewNotificationDefinition 

func NewNotificationDefinition(context *parsing.Context) *NotificationDefinition

func (*NotificationDefinition) GetKey 

func (self *NotificationDefinition) GetKey() string

(parsing.Mappable interface)

func (*NotificationDefinition) Inherit 

func (self *NotificationDefinition) Inherit(parentDefinition *NotificationDefinition)

type NotificationDefinitions 

type NotificationDefinitions map[string]*NotificationDefinition

func (NotificationDefinitions) Inherit 

func (self NotificationDefinitions) Inherit(parentDefinitions NotificationDefinitions)

type OperationAssignment 

type OperationAssignment struct {
	*Entity `name:"operation"`
	Name    string

	Description    *string                  `read:"description"`
	Implementation *InterfaceImplementation `read:"implementation,InterfaceImplementation"`
	Inputs         Values                   `read:"inputs,Value"`
	Outputs        OutputMappings           `read:"outputs,OutputMapping"` // introduced in TOSCA 1.3
}

func NewOperationAssignment 

func NewOperationAssignment(context *parsing.Context) *OperationAssignment

func (*OperationAssignment) GetKey 

func (self *OperationAssignment) GetKey() string

(parsing.Mappable interface)

func (*OperationAssignment) Normalize 

func (self *OperationAssignment) Normalize(normalInterface *normal.Interface) *normal.Operation

type OperationAssignments 

type OperationAssignments map[string]*OperationAssignment

func (OperationAssignments) CopyUnassigned 

func (self OperationAssignments) CopyUnassigned(assignments OperationAssignments)

func (OperationAssignments) Normalize 

func (self OperationAssignments) Normalize(normalInterface *normal.Interface)

func (OperationAssignments) RenderForGroup added in v0.21.0 

func (self OperationAssignments) RenderForGroup(definitions OperationDefinitions, context *parsing.Context)

func (OperationAssignments) RenderForNodeType added in v0.21.0 

func (self OperationAssignments) RenderForNodeType(nodeType *NodeType, definitions OperationDefinitions, context *parsing.Context)

func (OperationAssignments) RenderForRelationshipType added in v0.21.0 

func (self OperationAssignments) RenderForRelationshipType(relationshipType *RelationshipType, definitions OperationDefinitions, sourceNodeTemplate *NodeTemplate, context *parsing.Context)

type OperationDefinition 

type OperationDefinition struct {
	*Entity `name:"operation definition"`
	Name    string

	Description      *string                  `read:"description"`
	Implementation   *InterfaceImplementation `read:"implementation,InterfaceImplementation"`
	InputDefinitions ParameterDefinitions     `read:"inputs,ParameterDefinition"`
	Outputs          OutputMappings           `read:"outputs,OutputMapping"` // introduced in TOSCA 1.3
}

func NewOperationDefinition 

func NewOperationDefinition(context *parsing.Context) *OperationDefinition

func (*OperationDefinition) GetKey 

func (self *OperationDefinition) GetKey() string

(parsing.Mappable interface)

func (*OperationDefinition) Inherit 

func (self *OperationDefinition) Inherit(parentDefinition *OperationDefinition)

func (*OperationDefinition) Normalize 

func (self *OperationDefinition) Normalize(normalOperation *normal.Operation)

type OperationDefinitions 

type OperationDefinitions map[string]*OperationDefinition

func (OperationDefinitions) Inherit 

func (self OperationDefinitions) Inherit(parentDefinitions OperationDefinitions)

type OutputMapping added in v0.16.0 

type OutputMapping struct {
	*Entity `name:"output mapping"`
	Name    string

	EntityName    *string
	AttributePath []string

	SourceNodeTemplate *NodeTemplate `traverse:"ignore" json:"-" yaml:"-"`
}

func NewOutputMapping added in v0.16.0 

func NewOutputMapping(context *parsing.Context) *OutputMapping

func (*OutputMapping) GetKey added in v0.16.0 

func (self *OutputMapping) GetKey() string

(parsing.Mappable interface)

func (*OutputMapping) Normalize added in v0.16.0 

func (self *OutputMapping) Normalize(normalOutputs normal.Values)

func (*OutputMapping) RenderForGroup added in v0.18.0 

func (self *OutputMapping) RenderForGroup()

func (*OutputMapping) RenderForNodeType added in v0.21.0 

func (self *OutputMapping) RenderForNodeType(nodeType *NodeType)

func (*OutputMapping) RenderForRelationshipType added in v0.21.0 

func (self *OutputMapping) RenderForRelationshipType(relationshipType *RelationshipType, sourceNodeTemplate *NodeTemplate)

type OutputMappings added in v0.16.0 

type OutputMappings map[string]*OutputMapping

func (OutputMappings) CopyUnassigned added in v0.16.0 

func (self OutputMappings) CopyUnassigned(outputMappings OutputMappings)

func (OutputMappings) Inherit added in v0.16.0 

func (self OutputMappings) Inherit(parent OutputMappings)

func (OutputMappings) Normalize added in v0.16.0 

func (self OutputMappings) Normalize(normalOutputs normal.Values)

func (OutputMappings) RenderForGroup added in v0.18.0 

func (self OutputMappings) RenderForGroup()

func (OutputMappings) RenderForNodeType added in v0.21.0 

func (self OutputMappings) RenderForNodeType(nodeType *NodeType)

func (OutputMappings) RenderForRelationshipType added in v0.21.0 

func (self OutputMappings) RenderForRelationshipType(relationshipType *RelationshipType, sourceNodeTemplate *NodeTemplate)

type ParameterDefinition 

type ParameterDefinition struct {
	*PropertyDefinition `name:"parameter definition"`

	Value *Value `read:"value,Value"`
}

func NewParameterDefinition 

func NewParameterDefinition(context *parsing.Context) *ParameterDefinition

func (*ParameterDefinition) Inherit added in v0.20.1 

func (self *ParameterDefinition) Inherit(parentDefinition *ParameterDefinition)

func (*ParameterDefinition) Normalize 

func (self *ParameterDefinition) Normalize(context *parsing.Context) normal.Value

func (*ParameterDefinition) Render 

func (self *ParameterDefinition) Render()

(parsing.Renderable interface)

type ParameterDefinitions 

type ParameterDefinitions map[string]*ParameterDefinition

func (ParameterDefinitions) Inherit added in v0.20.1 

func (self ParameterDefinitions) Inherit(parentDefinitions ParameterDefinitions)

func (ParameterDefinitions) Normalize 

func (self ParameterDefinitions) Normalize(c normal.Values, context *parsing.Context)

func (ParameterDefinitions) Render 

func (self ParameterDefinitions) Render(kind string, mapped []string)

type Policies 

type Policies []*Policy

func (Policies) Normalize 

func (self Policies) Normalize(normalServiceTemplate *normal.ServiceTemplate)

type Policy 

type Policy struct {
	*Entity `name:"policy"`
	Name    string `namespace:""`

	PolicyTypeName                 *string            `read:"type" mandatory:""`
	Metadata                       Metadata           `read:"metadata,Metadata"` // introduced in TOSCA 1.1
	Description                    *string            `read:"description"`
	Properties                     Values             `read:"properties,Value"`
	TargetNodeTemplateOrGroupNames *[]string          `read:"targets"`
	TriggerDefinitions             TriggerDefinitions `read:"triggers,TriggerDefinition" inherit:"triggers,PolicyType"` // introduced in TOSCA 1.1

	PolicyType          *PolicyType   `lookup:"type,PolicyTypeName" traverse:"ignore" json:"-" yaml:"-"`
	TargetNodeTemplates NodeTemplates `lookup:"targets,TargetNodeTemplateOrGroupNames" traverse:"ignore" json:"-" yaml:"-"`
	TargetGroups        Groups        `lookup:"targets,TargetNodeTemplateOrGroupNames" traverse:"ignore" json:"-" yaml:"-"`
}

func NewPolicy 

func NewPolicy(context *parsing.Context) *Policy

func (*Policy) GetKey 

func (self *Policy) GetKey() string

(parsing.Mappable interface)

func (*Policy) Normalize 

func (self *Policy) Normalize(normalServiceTemplate *normal.ServiceTemplate) *normal.Policy

func (*Policy) Render 

func (self *Policy) Render()

(parsing.Renderable interface)

type PolicyType 

type PolicyType struct {
	*Type `name:"policy type"`

	PropertyDefinitions            PropertyDefinitions `read:"properties,PropertyDefinition" inherit:"properties,Parent"`
	TargetNodeTypeOrGroupTypeNames *[]string           `read:"targets" inherit:"targets,Parent"`
	TriggerDefinitions             TriggerDefinitions  `read:"triggers,TriggerDefinition" inherit:"triggers,Parent"` // introduced in TOSCA 1.1

	Parent           *PolicyType `lookup:"derived_from,ParentName" traverse:"ignore" json:"-" yaml:"-"`
	TargetNodeTypes  NodeTypes   `lookup:"targets,TargetNodeTypeOrGroupTypeNames" inherit:"targets,Parent" traverse:"ignore" json:"-" yaml:"-"`
	TargetGroupTypes GroupTypes  `lookup:"targets,TargetNodeTypeOrGroupTypeNames" inherit:"targets,Parent" traverse:"ignore" json:"-" yaml:"-"`
}

func NewPolicyType 

func NewPolicyType(context *parsing.Context) *PolicyType

func (*PolicyType) GetParent 

func (self *PolicyType) GetParent() parsing.EntityPtr

(parsing.Hierarchical interface)

func (*PolicyType) Inherit 

func (self *PolicyType) Inherit()

(parsing.Inherits interface)

func (*PolicyType) Render 

func (self *PolicyType) Render()

(parsing.Renderable interface)

type PolicyTypes 

type PolicyTypes []*PolicyType

type PropertyDefinition 

type PropertyDefinition struct {
	*AttributeDefinition `name:"property definition"`

	Required *bool `read:"required"`
}

func NewPropertyDefinition 

func NewPropertyDefinition(context *parsing.Context) *PropertyDefinition

func (*PropertyDefinition) Inherit 

func (self *PropertyDefinition) Inherit(parentDefinition *PropertyDefinition)

func (*PropertyDefinition) IsRequired 

func (self *PropertyDefinition) IsRequired() bool

func (*PropertyDefinition) Render 

func (self *PropertyDefinition) Render()

(parsing.Renderable interface)

type PropertyDefinitions 

type PropertyDefinitions map[string]*PropertyDefinition

func (PropertyDefinitions) Inherit 

func (self PropertyDefinitions) Inherit(parentDefinitions PropertyDefinitions)

type PropertyFilter 

type PropertyFilter struct {
	*Entity `name:"property filter"`
	Name    string

	ConstraintClauses ConstraintClauses
}

func NewPropertyFilter 

func NewPropertyFilter(context *parsing.Context) *PropertyFilter

func (*PropertyFilter) Normalize 

func (self *PropertyFilter) Normalize(normalFunctionCallMap normal.FunctionCallMap) normal.FunctionCalls

type PropertyFilters 

type PropertyFilters []*PropertyFilter

func (PropertyFilters) Normalize 

func (self PropertyFilters) Normalize(normalFunctionCallMap normal.FunctionCallMap)

type PropertyMapping 

type PropertyMapping struct {
	*Entity `name:"property mapping"`
	Name    string

	InputName        *string
	NodeTemplateName *string // deprecated in TOSCA 1.3
	PropertyName     *string // deprecated in TOSCA 1.3

	InputDefinition *ParameterDefinition `traverse:"ignore" json:"-" yaml:"-"`
	NodeTemplate    *NodeTemplate        `traverse:"ignore" json:"-" yaml:"-"` // deprecated in TOSCA 1.3
	Value           *Value               `traverse:"ignore" json:"-" yaml:"-"` // deprecated in TOSCA 1.3
}

func NewPropertyMapping 

func NewPropertyMapping(context *parsing.Context) *PropertyMapping

func (*PropertyMapping) GetKey added in v0.18.0 

func (self *PropertyMapping) GetKey() string

(parsing.Mappable interface)

func (*PropertyMapping) Render 

func (self *PropertyMapping) Render(inputDefinitions ParameterDefinitions)

type PropertyMappings 

type PropertyMappings map[string]*PropertyMapping

func (PropertyMappings) Render added in v0.18.0 

func (self PropertyMappings) Render(inputDefinitions ParameterDefinitions)

type Range 

type Range struct {
	Lower uint64 `json:"lower" yaml:"lower"`
	Upper uint64 `json:"upper" yaml:"upper"`
}

func (*Range) InRange 

func (self *Range) InRange(number uint64) bool

type RangeEntity 

type RangeEntity struct {
	*Entity `name:"range"`

	Range *Range `traverse:"ignore"`
}

func NewRangeEntity 

func NewRangeEntity(context *parsing.Context) *RangeEntity

type RelationshipAssignment 

type RelationshipAssignment struct {
	*Entity `name:"relationship"`

	RelationshipTemplateNameOrTypeName *string              `read:"type"`
	Properties                         Values               `read:"properties,Value"`
	Attributes                         Values               `read:"attributes,AttributeValue"` // missing in spec
	Interfaces                         InterfaceAssignments `read:"interfaces,InterfaceAssignment"`

	RelationshipTemplate *RelationshipTemplate `lookup:"type,RelationshipTemplateNameOrTypeName" traverse:"ignore" json:"-" yaml:"-"`
	RelationshipType     *RelationshipType     `lookup:"type,RelationshipTemplateNameOrTypeName" traverse:"ignore" json:"-" yaml:"-"`
}

func NewRelationshipAssignment 

func NewRelationshipAssignment(context *parsing.Context) *RelationshipAssignment

func (*RelationshipAssignment) GetType 

func (self *RelationshipAssignment) GetType(definition *RelationshipDefinition) *RelationshipType

func (*RelationshipAssignment) Normalize 

func (self *RelationshipAssignment) Normalize(definition *RelationshipDefinition, normalRelationship *normal.Relationship)

func (*RelationshipAssignment) Render 

func (self *RelationshipAssignment) Render(definition *RelationshipDefinition, sourceNodeTemplate *NodeTemplate)

type RelationshipDefinition 

type RelationshipDefinition struct {
	*Entity `name:"relationship definition"`

	RelationshipTypeName *string              `read:"type"` // mandatory only if cannot be inherited
	InterfaceDefinitions InterfaceDefinitions `read:"interfaces,InterfaceDefinition" inherit:"interfaces,RelationshipType"`

	RelationshipType *RelationshipType `lookup:"type,RelationshipTypeName" traverse:"ignore" json:"-" yaml:"-"`
	// contains filtered or unexported fields
}

func NewRelationshipDefinition 

func NewRelationshipDefinition(context *parsing.Context) *RelationshipDefinition

func (*RelationshipDefinition) Inherit 

func (self *RelationshipDefinition) Inherit(parentDefinition *RelationshipDefinition)

func (*RelationshipDefinition) NewDefaultAssignment 

func (self *RelationshipDefinition) NewDefaultAssignment(context *parsing.Context) *RelationshipAssignment

func (*RelationshipDefinition) Render 

func (self *RelationshipDefinition) Render()

(parsing.Renderable interface)

type RelationshipTemplate 

type RelationshipTemplate struct {
	*Entity `name:"relationship template"`
	Name    string `namespace:""`

	CopyRelationshipTemplateName *string              `read:"copy"`
	RelationshipTypeName         *string              `read:"type" mandatory:""`
	Metadata                     Metadata             `read:"metadata,Metadata"` // introduced in TOSCA 1.1
	Description                  *string              `read:"description"`
	Properties                   Values               `read:"properties,Value"`
	Attributes                   Values               `read:"attributes,AttributeValue"`
	Interfaces                   InterfaceAssignments `read:"interfaces,InterfaceAssignment"`

	CopyRelationshipTemplate *RelationshipTemplate `lookup:"copy,CopyRelationshipTemplateName" traverse:"ignore" json:"-" yaml:"-"`
	RelationshipType         *RelationshipType     `lookup:"type,RelationshipTypeName" traverse:"ignore" json:"-" yaml:"-"`
}

func NewRelationshipTemplate 

func NewRelationshipTemplate(context *parsing.Context) *RelationshipTemplate

func (*RelationshipTemplate) Normalize added in v0.16.0 

func (self *RelationshipTemplate) Normalize(normalRelationship *normal.Relationship)

func (*RelationshipTemplate) PreRead 

func (self *RelationshipTemplate) PreRead()

(parsing.PreReadable interface)

func (*RelationshipTemplate) Render 

func (self *RelationshipTemplate) Render()

(parsing.Renderable interface)

type RelationshipTemplates 

type RelationshipTemplates []*RelationshipTemplate

type RelationshipType 

type RelationshipType struct {
	*Type `name:"relationship type"`

	PropertyDefinitions            PropertyDefinitions  `read:"properties,PropertyDefinition" inherit:"properties,Parent"`
	AttributeDefinitions           AttributeDefinitions `read:"attributes,AttributeDefinition" inherit:"attributes,Parent"`
	InterfaceDefinitions           InterfaceDefinitions `read:"interfaces,InterfaceDefinition" inherit:"interfaces,Parent"`
	ValidTargetCapabilityTypeNames *[]string            `read:"valid_target_types" inherit:"valid_target_types,Parent"`

	Parent                     *RelationshipType `lookup:"derived_from,ParentName" traverse:"ignore" json:"-" yaml:"-"`
	ValidTargetCapabilityTypes CapabilityTypes   `` /* 130-byte string literal not displayed */
}

func NewRelationshipType 

func NewRelationshipType(context *parsing.Context) *RelationshipType

func (*RelationshipType) GetParent 

func (self *RelationshipType) GetParent() parsing.EntityPtr

(parsing.Hierarchical interface)

func (*RelationshipType) Inherit 

func (self *RelationshipType) Inherit()

(parsing.Inherits interface)

type RelationshipTypes 

type RelationshipTypes []*RelationshipType

type Repositories 

type Repositories []*Repository

type Repository 

type Repository struct {
	*Entity `name:"repository"`
	Name    string `namespace:""`

	Description *string `read:"description"`
	URL         *string `read:"url" mandatory:""`
	Credential  *Value  `read:"credential,Value"` // tosca:Credential
	// contains filtered or unexported fields
}

func NewRepository 

func NewRepository(context *parsing.Context) *Repository

func (*Repository) GetURL 

func (self *Repository) GetURL() exturl.URL

func (*Repository) Render 

func (self *Repository) Render()

(parsing.Renderable interface)

type RequirementAssignment 

type RequirementAssignment struct {
	*Entity `name:"requirement"`
	Name    string

	TargetCapabilityNameOrTypeName   *string                 `read:"capability"`
	TargetNodeTemplateNameOrTypeName *string                 `read:"node"`
	TargetNodeFilter                 *NodeFilter             `read:"node_filter,NodeFilter"`
	Relationship                     *RelationshipAssignment `read:"relationship,RelationshipAssignment"`
	Count                            *int64                  `read:"count"`      // introduced in TOSCA 2.0, replacing "occurrences"
	Directives                       *[]string               `read:"directives"` // introduced in TOSCA 2.0
	Optional                         *bool                   `read:"optional"`   // introduced in TOSCA 2.0

	TargetCapabilityType *CapabilityType `lookup:"capability,?TargetCapabilityNameOrTypeName" traverse:"ignore" json:"-" yaml:"-"`
	TargetNodeTemplate   *NodeTemplate   `lookup:"node,TargetNodeTemplateNameOrTypeName" traverse:"ignore" json:"-" yaml:"-"`
	TargetNodeType       *NodeType       `lookup:"node,TargetNodeTemplateNameOrTypeName" traverse:"ignore" json:"-" yaml:"-"`
	// contains filtered or unexported fields
}

func NewDefaultRequirementAssignment 

func NewDefaultRequirementAssignment(index int, definition *RequirementDefinition, context *parsing.Context) *RequirementAssignment

func NewRequirementAssignment 

func NewRequirementAssignment(context *parsing.Context) *RequirementAssignment

func (*RequirementAssignment) GetDefinition 

func (self *RequirementAssignment) GetDefinition(nodeTemplate *NodeTemplate) (*RequirementDefinition, bool)

func (*RequirementAssignment) Normalize 

func (self *RequirementAssignment) Normalize(nodeTemplate *NodeTemplate, normalNodeTemplate *normal.NodeTemplate) *normal.Requirement

type RequirementAssignments 

type RequirementAssignments []*RequirementAssignment

func (*RequirementAssignments) Count added in v0.20.0 

func (self *RequirementAssignments) Count(name string) uint64

func (RequirementAssignments) Normalize 

func (self RequirementAssignments) Normalize(nodeTemplate *NodeTemplate, normalNodeTemplate *normal.NodeTemplate)

func (*RequirementAssignments) Render 

func (self *RequirementAssignments) Render(sourceNodeTemplate *NodeTemplate, context *parsing.Context)

type RequirementDefinition 

type RequirementDefinition struct {
	*Entity `name:"requirement definition"`
	Name    string

	TargetCapabilityTypeName *string                 `read:"capability"` // mandatory only if cannot be inherited
	TargetNodeTypeName       *string                 `read:"node"`
	RelationshipDefinition   *RelationshipDefinition `read:"relationship,RelationshipDefinition"`
	CountRange               *RangeEntity            `read:"count_range,RangeEntity"` // "occurrences" in TOSCA 1.3

	TargetCapabilityType *CapabilityType `lookup:"capability,TargetCapabilityTypeName" traverse:"ignore" json:"-" yaml:"-"`
	TargetNodeType       *NodeType       `lookup:"node,TargetNodeTypeName" traverse:"ignore" json:"-" yaml:"-"`

	DefaultCountRange ard.List
	// contains filtered or unexported fields
}

func NewRequirementDefinition 

func NewRequirementDefinition(context *parsing.Context) *RequirementDefinition

func (*RequirementDefinition) GetKey 

func (self *RequirementDefinition) GetKey() string

(parsing.Mappable interface)

func (*RequirementDefinition) Inherit 

func (self *RequirementDefinition) Inherit(parentDefinition *RequirementDefinition)

func (*RequirementDefinition) Render 

func (self *RequirementDefinition) Render()

(parsing.Renderable interface)

type RequirementDefinitions 

type RequirementDefinitions map[string]*RequirementDefinition

func (RequirementDefinitions) Inherit 

func (self RequirementDefinitions) Inherit(parentDefinitions RequirementDefinitions)

type RequirementMapping 

type RequirementMapping struct {
	*Entity `name:"requirement mapping"`
	Name    string

	NodeTemplateName *string
	RequirementName  *string

	NodeTemplate *NodeTemplate          `traverse:"ignore" json:"-" yaml:"-"`
	Requirement  *RequirementAssignment `traverse:"ignore" json:"-" yaml:"-"`
}

func NewRequirementMapping 

func NewRequirementMapping(context *parsing.Context) *RequirementMapping

func (*RequirementMapping) GetKey added in v0.18.0 

func (self *RequirementMapping) GetKey() string

(parsing.Mappable interface)

func (*RequirementMapping) GetRequirementDefinition added in v0.18.0 

func (self *RequirementMapping) GetRequirementDefinition() (*RequirementDefinition, bool)

func (*RequirementMapping) Render 

func (self *RequirementMapping) Render()

(parsing.Renderable interface)

type RequirementMappings 

type RequirementMappings map[string]*RequirementMapping

type ScalarUnit 

type ScalarUnit struct {
	CanonicalString string `json:"$string" yaml:"$string"`
	CanonicalNumber any    `json:"$number" yaml:"$number"` // float64 or uint64
	OriginalString  string `json:"$originalString" yaml:"$originalString"`

	Scalar float64 `json:"scalar" yaml:"scalar"`
	Unit   string  `json:"unit" yaml:"unit"`
	// contains filtered or unexported fields
}

func ReadScalarUnit 

func ReadScalarUnit(context *parsing.Context, name string, canonicalUnit string, canonicalUnitSingular string, canonicalUnitPlural string, re *regexp.Regexp, measures ScalarUnitMeasures, countable bool, caseSensitive bool) *ScalarUnit

func (*ScalarUnit) Compare 

func (self *ScalarUnit) Compare(data any) (int, error)

func (*ScalarUnit) String 

func (self *ScalarUnit) String() string

(fmt.Stringer interface)

type ScalarUnitMeasures 

type ScalarUnitMeasures map[string]float64

func (ScalarUnitMeasures) Get 

func (self ScalarUnitMeasures) Get(unit string, caseSensitive bool) (string, float64)

type Schema 

type Schema struct {
	*Entity `name:"schema"`

	Metadata          Metadata          `read:"metadata,Metadata"` // introduced in TOSCA 1.3
	Description       *string           `read:"description"`
	DataTypeName      *string           `read:"type" mandatory:""`
	ConstraintClauses ConstraintClauses `read:"constraints,[]ConstraintClause" traverse:"ignore"`
	KeySchema         *Schema           `read:"key_schema,Schema"`   // introduced in TOSCA 1.3
	EntrySchema       *Schema           `read:"entry_schema,Schema"` // mandatory if list or map

	DataType *DataType `lookup:"type,DataTypeName" traverse:"ignore" json:"-" yaml:"-"`
}

func GetListSchemas added in v0.21.0 

func GetListSchemas(dataType *DataType, dataDefinition DataDefinition) *Schema

func NewSchema 

func NewSchema(context *parsing.Context) *Schema

func (*Schema) GetConstraintClauses added in v0.21.0 

func (self *Schema) GetConstraintClauses() ConstraintClauses

(DataDefinition interface)

func (*Schema) GetConstraints 

func (self *Schema) GetConstraints() ConstraintClauses

func (*Schema) GetDescription added in v0.21.0 

func (self *Schema) GetDescription() string

(DataDefinition interface)

func (*Schema) GetEntrySchema added in v0.21.0 

func (self *Schema) GetEntrySchema() *Schema

(DataDefinition interface)

func (*Schema) GetKeySchema added in v0.21.0 

func (self *Schema) GetKeySchema() *Schema

(DataDefinition interface)

func (*Schema) GetTypeMetadata added in v0.21.0 

func (self *Schema) GetTypeMetadata() Metadata

(DataDefinition interface)

func (*Schema) LookupDataType 

func (self *Schema) LookupDataType() bool

TODO: do we need this?

func (*Schema) Render 

func (self *Schema) Render()

(parsing.Renderable interface)

func (*Schema) ToValueMeta added in v0.21.0 

func (self *Schema) ToValueMeta() *normal.ValueMeta

(DataDefinition interface)

type ServiceFile added in v0.21.0 

type ServiceFile struct {
	*File `name:"service file"`

	ServiceTemplate *ServiceTemplate `read:"service_template,ServiceTemplate"`
}

func NewServiceFile added in v0.21.0 

func NewServiceFile(context *parsing.Context) *ServiceFile

func (*ServiceFile) NormalizeServiceTemplate added in v0.21.0 

func (self *ServiceFile) NormalizeServiceTemplate() *normal.ServiceTemplate

normal.Normalizable interface

type ServiceTemplate 

type ServiceTemplate struct {
	*Entity `name:"service template"`

	Description           *string               `read:"description"`
	NodeTemplates         NodeTemplates         `read:"node_templates,NodeTemplate"`
	RelationshipTemplates RelationshipTemplates `read:"relationship_templates,RelationshipTemplate"`
	Groups                Groups                `read:"groups,Group"`
	Policies              Policies              `read:"policies,<>Policy"`
	InputDefinitions      ParameterDefinitions  `read:"inputs,ParameterDefinition"`
	OutputDefinitions     ParameterDefinitions  `read:"outputs,ParameterDefinition"`
	WorkflowDefinitions   WorkflowDefinitions   `read:"workflows,WorkflowDefinition"`
	SubstitutionMappings  *SubstitutionMappings `read:"substitution_mappings,SubstitutionMappings"`
}

func NewServiceTemplate 

func NewServiceTemplate(context *parsing.Context) *ServiceTemplate

func (*ServiceTemplate) GetNodeTemplatesOfType added in v0.21.0 

func (self *ServiceTemplate) GetNodeTemplatesOfType(nodeType *NodeType) []*NodeTemplate

func (*ServiceTemplate) Normalize added in v0.21.0 

func (self *ServiceTemplate) Normalize(normalServiceTemplate *normal.ServiceTemplate)

func (*ServiceTemplate) Render added in v0.21.0 

func (self *ServiceTemplate) Render()

(parsing.Renderable interface)

func (*ServiceTemplate) SetInputs added in v0.21.0 

func (self *ServiceTemplate) SetInputs(inputs map[string]ard.Value)

parsing.HasInputs interface

type SubstitutionMappings 

type SubstitutionMappings struct {
	*Entity `name:"substitution mappings"`

	NodeTypeName        *string             `read:"node_type" mandatory:""`
	CapabilityMappings  CapabilityMappings  `read:"capabilities,CapabilityMapping"`
	RequirementMappings RequirementMappings `read:"requirements,RequirementMapping"`
	PropertyMappings    PropertyMappings    `read:"properties,PropertyMapping"`     // introduced in TOSCA 1.2
	AttributeMappings   AttributeMappings   `read:"attributes,AttributeMapping"`    // introduced in TOSCA 1.3
	InterfaceMappings   InterfaceMappings   `read:"interfaces,InterfaceMapping"`    // introduced in TOSCA 1.2
	SubstitutionFilter  *NodeFilter         `read:"substitution_filter,NodeFilter"` // introduced in TOSCA 1.3

	NodeType *NodeType `lookup:"node_type,NodeTypeName" traverse:"ignore" json:"-" yaml:"-"`
}

func NewSubstitutionMappings 

func NewSubstitutionMappings(context *parsing.Context) *SubstitutionMappings

func (*SubstitutionMappings) IsRequirementMapped 

func (self *SubstitutionMappings) IsRequirementMapped(nodeTemplate *NodeTemplate, requirementName string) bool

func (*SubstitutionMappings) Normalize 

func (self *SubstitutionMappings) Normalize(normalServiceTemplate *normal.ServiceTemplate) *normal.Substitution

func (*SubstitutionMappings) Render added in v0.18.0 

func (self *SubstitutionMappings) Render(inputDefinitions ParameterDefinitions)

type Timestamp 

type Timestamp struct {
	CanonicalNumber int64  `json:"$number" yaml:"$number"`
	CanonicalString string `json:"$string" yaml:"$string"`
	OriginalString  string `json:"$originalString" yaml:"$originalString"`

	Year     uint32  `json:"year" yaml:"year"`
	Month    uint32  `json:"month" yaml:"month"`
	Day      uint32  `json:"day" yaml:"day"`
	Hour     uint32  `json:"hour" yaml:"hour"`
	Minute   uint32  `json:"minute" yaml:"minute"`
	Second   uint32  `json:"second" yaml:"second"`
	Fraction float64 `json:"fraction" yaml:"fraction"`
	TZSign   string  `json:"tzSign" yaml:"tzSign"`
	TZHour   uint32  `json:"tzHour" yaml:"tzHour"`
	TZMinute uint32  `json:"tzMinute" yaml:"tzMinute"`
}

func (*Timestamp) Compare 

func (self *Timestamp) Compare(data any) (int, error)

func (*Timestamp) Location 

func (self *Timestamp) Location() *time.Location

Convert timezone to Go time.Location

func (*Timestamp) String 

func (self *Timestamp) String() string

(fmt.Stringer interface)

func (*Timestamp) Time 

func (self *Timestamp) Time() time.Time

Convert to Go time.Time

type TriggerDefinition 

type TriggerDefinition struct {
	*Entity `name:"trigger definition" json:"-" yaml:"-"`
	Name    string

	Description  *string                     `read:"description"`
	Event        *string                     `read:"event" mandatory:""`
	Schedule     *Value                      `read:"schedule,Value"` // tosca:TimeInterval
	TargetFilter *EventFilter                `read:"target_filter,EventFilter"`
	Condition    *TriggerDefinitionCondition `read:"condition,TriggerDefinitionCondition"`
	Action       WorkflowActivityDefinitions `read:"action,[]WorkflowActivityDefinition" mandatory:""`
}

func NewTriggerDefinition 

func NewTriggerDefinition(context *parsing.Context) *TriggerDefinition

func (*TriggerDefinition) GetKey 

func (self *TriggerDefinition) GetKey() string

(parsing.Mappable interface)

func (*TriggerDefinition) Normalize 

func (self *TriggerDefinition) Normalize(normalPolicy *normal.Policy) *normal.PolicyTrigger

func (*TriggerDefinition) Render 

func (self *TriggerDefinition) Render()

(parsing.Renderable interface)

type TriggerDefinitionCondition 

type TriggerDefinitionCondition struct {
	*Entity `name:"trigger definition condition" json:"-" yaml:"-"`

	Constraint  *ConditionClause `read:"constraint,ConditionClause"` // why is this called "constraint"?
	Period      *Value           `read:"period,Value"`               // scalar-unit.time
	Evaluations *int             `read:"evaluations"`
	Method      *string          `read:"method"`
}

func NewTriggerDefinitionCondition 

func NewTriggerDefinitionCondition(context *parsing.Context) *TriggerDefinitionCondition

func (*TriggerDefinitionCondition) Render added in v0.19.0 

func (self *TriggerDefinitionCondition) Render()

(parsing.Renderable interface)

type TriggerDefinitions 

type TriggerDefinitions map[string]*TriggerDefinition

func (TriggerDefinitions) Normalize 

func (self TriggerDefinitions) Normalize(normalPolicy *normal.Policy)

type Type 

type Type struct {
	*Entity `json:"-" yaml:"-"`
	Name    string `namespace:""`

	ParentName  *string  `read:"derived_from"`
	Version     *Value   `read:"version,Value"`
	Metadata    Metadata `read:"metadata,!Metadata"`
	Description *string  `read:"description"`
}

func NewType 

func NewType(context *parsing.Context) *Type

func (*Type) GetDescription 

func (self *Type) GetDescription() (string, bool)

(parsing.HasMetadata interface)

func (*Type) GetMetadata 

func (self *Type) GetMetadata() (map[string]string, bool)

(parsing.HasMetadata interface)

func (*Type) GetMetadataValue 

func (self *Type) GetMetadataValue(key string) (string, bool)

func (*Type) Render added in v0.19.0 

func (self *Type) Render()

(parsing.Renderable interface)

func (*Type) SetMetadata 

func (self *Type) SetMetadata(name string, value string) bool

(parsing.HasMetadata interface)

type Value 

type Value struct {
	*Entity `name:"value"`
	Name    string

	ConstraintClauses ConstraintClauses
	Description       *string // not used since TOSCA 2.0

	DataType *DataType         `traverse:"ignore" json:"-" yaml:"-"`
	Meta     *normal.ValueMeta `traverse:"ignore" json:"-" yaml:"-"`
}

func NewValue 

func NewValue(context *parsing.Context) *Value

func ReadAndRenderBare added in v0.20.1 

func ReadAndRenderBare(context *parsing.Context, dataType *DataType, definition DataDefinition) *Value

func (*Value) GetKey 

func (self *Value) GetKey() string

(parsing.Mappable interface)

func (*Value) Normalize 

func (self *Value) Normalize() normal.Value

func (*Value) Render added in v0.20.1 

func (self *Value) Render(dataType *DataType, dataDefinition DataDefinition, bare bool, allowNil bool)

func (*Value) RenderDataType 

func (self *Value) RenderDataType(dataTypeName string)

func (*Value) RenderProperty 

func (self *Value) RenderProperty(dataType *DataType, dataDefinition *PropertyDefinition)

func (*Value) String added in v0.16.0 

func (self *Value) String() string

(fmt.Stringer interface)

type ValueList 

type ValueList struct {
	EntryConstraints ConstraintClauses
	Slice            []any
}

func NewValueList 

func NewValueList(length int, entryConstraints ConstraintClauses) *ValueList

func (*ValueList) Normalize 

func (self *ValueList) Normalize(context *parsing.Context) *normal.List

func (*ValueList) Set 

func (self *ValueList) Set(index int, value any)

type ValueMap 

type ValueMap struct {
	KeyConstraints   ConstraintClauses
	ValueConstraints ConstraintClauses
	Map              ard.Map
}

func NewValueMap 

func NewValueMap(keyConstraints ConstraintClauses, valueConstraints ConstraintClauses) *ValueMap

func (*ValueMap) Normalize 

func (self *ValueMap) Normalize(context *parsing.Context) *normal.Map

func (*ValueMap) Put 

func (self *ValueMap) Put(key any, value any)

type Values 

type Values map[string]*Value

func (Values) CopyUnassigned 

func (self Values) CopyUnassigned(values Values)

func (Values) Normalize 

func (self Values) Normalize(normalConstrainables normal.Values)

func (Values) RenderAttributes 

func (self Values) RenderAttributes(definitions AttributeDefinitions, context *parsing.Context)

func (Values) RenderInputs added in v0.20.1 

func (self Values) RenderInputs(definitions ParameterDefinitions, context *parsing.Context)

func (Values) RenderProperties 

func (self Values) RenderProperties(definitions PropertyDefinitions, context *parsing.Context)

type Version 

type Version struct {
	CanonicalString string `json:"$string" yaml:"$string"`
	OriginalString  string `json:"$originalString" yaml:"$originalString"`
	Comparer        string `json:"$comparer" yaml:"$comparer"`

	Major     uint32 `json:"major" yaml:"major"`
	Minor     uint32 `json:"minor" yaml:"minor"`
	Fix       uint32 `json:"fix" yaml:"fix"`
	Qualifier string `json:"qualifier" yaml:"qualifier"`
	Build     uint32 `json:"build" yaml:"build"`
}

func (*Version) Compare 

func (self *Version) Compare(data any) (int, error)

func (*Version) SetComparer 

func (self *Version) SetComparer(comparer string)

HasComparer interface

func (*Version) String 

func (self *Version) String() string

(fmt.Stringer interface)

type WorkflowActivityCallOperation 

type WorkflowActivityCallOperation struct {
	*Entity `name:"workflow activity call operation"`
	Name    string

	InterfaceAndOperation *string `read:"operation"`
	Inputs                Values  `read:"inputs,Value"` // introduced in TOSCA 1.3

	Interface *InterfaceAssignment `json:"-" yaml:"-"`
	Operation *OperationAssignment `json:"-" yaml:"-"`
}

func NewWorkflowActivityCallOperation 

func NewWorkflowActivityCallOperation(context *parsing.Context) *WorkflowActivityCallOperation

func (*WorkflowActivityCallOperation) Normalize added in v0.19.0 

func (self *WorkflowActivityCallOperation) Normalize(normalWorkflowActivity *normal.WorkflowActivity)

func (*WorkflowActivityCallOperation) Render 

func (self *WorkflowActivityCallOperation) Render(stepDefinition *WorkflowStepDefinition)

type WorkflowActivityDefinition 

type WorkflowActivityDefinition struct {
	*Entity `name:"workflow activity definition"`

	DelegateWorkflowDefinitionName *string
	InlineWorkflowDefinitionName   *string
	SetNodeState                   *string
	CallOperation                  *WorkflowActivityCallOperation

	DelegateWorkflowDefinition *WorkflowDefinition `lookup:"delegate,DelegateWorkflowDefinitionName" traverse:"ignore" json:"-" yaml:"-"`
	InlineWorkflowDefinition   *WorkflowDefinition `lookup:"inline,InlineWorkflowDefinitionName" traverse:"ignore" json:"-" yaml:"-"`
}

func NewWorkflowActivityDefinition 

func NewWorkflowActivityDefinition(context *parsing.Context) *WorkflowActivityDefinition

func (*WorkflowActivityDefinition) Normalize 

func (self *WorkflowActivityDefinition) Normalize(normalWorkflowStep *normal.WorkflowStep) *normal.WorkflowActivity

func (*WorkflowActivityDefinition) Render 

func (self *WorkflowActivityDefinition) Render(stepDefinition *WorkflowStepDefinition)

type WorkflowActivityDefinitions 

type WorkflowActivityDefinitions []*WorkflowActivityDefinition

type WorkflowDefinition 

type WorkflowDefinition struct {
	*Entity `name:"workflow definition"`
	Name    string `namespace:""`

	Metadata                Metadata                        `read:"metadata,Metadata"`
	Description             *string                         `read:"description"`
	InputDefinitions        PropertyDefinitions             `read:"inputs,PropertyDefinition"`
	PreconditionDefinitions WorkflowPreconditionDefinitions `read:"preconditions,WorkflowPreconditionDefinition"`
	StepDefinitions         WorkflowStepDefinitions         `read:"steps,WorkflowStepDefinition"`
}

func NewWorkflowDefinition 

func NewWorkflowDefinition(context *parsing.Context) *WorkflowDefinition

func (*WorkflowDefinition) GetKey 

func (self *WorkflowDefinition) GetKey() string

(parsing.Mappable interface)

func (*WorkflowDefinition) Normalize 

func (self *WorkflowDefinition) Normalize(normalServiceTemplate *normal.ServiceTemplate) *normal.Workflow

func (*WorkflowDefinition) Render 

func (self *WorkflowDefinition) Render()

(parsing.Renderable interface)

type WorkflowDefinitions 

type WorkflowDefinitions map[string]*WorkflowDefinition

func (WorkflowDefinitions) Normalize 

func (self WorkflowDefinitions) Normalize(normalServiceTemplate *normal.ServiceTemplate)

type WorkflowPreconditionDefinition 

type WorkflowPreconditionDefinition struct {
	*Entity `name:"workflow precondition definition"`

	TargetNodeTemplateOrGroupName *string          `read:"target" mandatory:""`
	TargetNodeRequirementName     *string          `read:"target_relationship"`
	ConditionClause               *ConditionClause `read:"condition,ConditionClauseAnd"`

	TargetNodeTemplate *NodeTemplate `lookup:"target,TargetNodeTemplateOrGroupName" traverse:"ignore" json:"-" yaml:"-"`
	TargetGroup        *Group        `lookup:"target,TargetNodeTemplateOrGroupName" traverse:"ignore" json:"-" yaml:"-"`
}

func NewWorkflowPreconditionDefinition 

func NewWorkflowPreconditionDefinition(context *parsing.Context) *WorkflowPreconditionDefinition

type WorkflowPreconditionDefinitions 

type WorkflowPreconditionDefinitions []*WorkflowPreconditionDefinition

type WorkflowStepDefinition 

type WorkflowStepDefinition struct {
	*Entity `name:"workflow step definition"`
	Name    string

	TargetNodeTemplateOrGroupName *string                     `read:"target" mandatory:""`
	TargetNodeRequirementName     *string                     `read:"target_relationship"`
	OperationHost                 *string                     `read:"operation_host"`
	FilterConditionClauses        *ConditionClause            `read:"filter,ConditionClauseAnd"` // spec is wrong, says constraint clause
	ActivityDefinitions           WorkflowActivityDefinitions `read:"activities,[]WorkflowActivityDefinition" mandatory:""`
	OnSuccessStepNames            *[]string                   `read:"on_success"`
	OnFailureStepNames            *[]string                   `read:"on_failure"`

	TargetNodeTemplate *NodeTemplate             `lookup:"target,TargetNodeTemplateOrGroupName" traverse:"ignore" json:"-" yaml:"-"`
	TargetGroup        *Group                    `lookup:"target,TargetNodeTemplateOrGroupName" traverse:"ignore" json:"-" yaml:"-"`
	OnSuccessSteps     []*WorkflowStepDefinition // custom lookup
	OnFailureSteps     []*WorkflowStepDefinition // custom lookup
}

func NewWorkflowStepDefinition 

func NewWorkflowStepDefinition(context *parsing.Context) *WorkflowStepDefinition

func (*WorkflowStepDefinition) GetKey 

func (self *WorkflowStepDefinition) GetKey() string

(parsing.Mappable interface)

func (*WorkflowStepDefinition) Normalize 

func (self *WorkflowStepDefinition) Normalize(normalWorkflow *normal.Workflow) *normal.WorkflowStep

func (*WorkflowStepDefinition) NormalizeNext 

func (self *WorkflowStepDefinition) NormalizeNext(normalWorkflowStep *normal.WorkflowStep, normalWorkflow *normal.Workflow)

func (*WorkflowStepDefinition) Render 

func (self *WorkflowStepDefinition) Render(definitions WorkflowStepDefinitions)

type WorkflowStepDefinitions 

type WorkflowStepDefinitions map[string]*WorkflowStepDefinition

func (WorkflowStepDefinitions) Normalize 

func (self WorkflowStepDefinitions) Normalize(normalWorkflow *normal.Workflow)

func (WorkflowStepDefinitions) Render 

func (self WorkflowStepDefinitions) Render()

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.