transformer

Documentation

Index

• Constants
• type Artifact
  • func (a *Artifact) GetConfig(configName ConfigType, obj interface{}) (err error)
• type ArtifactProcessConfig
• type ArtifactProcessingMode
• type ArtifactType
• type Config
• type ConfigType
• type DirectoryDetect
• type InvokedByDefault
• type PathMapping
• type PathMappingType
• type PathType
• type ProducedArtifact
• type TransformInput
• type TransformOutput
• type Transformer
  • func NewTransformer() Transformer
• type TransformerDisabledError
  • func (e *TransformerDisabledError) Error() string
• type TransformerSpec

Constants

const (
	// LabelName stores label of Name
	LabelName = types.GroupName + "/name"
)

const TransformerKind = "Transformer"

TransformerKind represents the Transformer kind

Types

type Artifact

type Artifact struct {
	Name        string               `yaml:"name,omitempty" json:"name,omitempty"`
	Type        ArtifactType         `yaml:"type,omitempty" json:"type,omitempty"`
	ProcessWith metav1.LabelSelector `yaml:"processWith,omitempty" json:"processWith,omitempty"` // Selector for choosing transformers that should process this artifact, empty is everything

	Paths   map[PathType][]string      `yaml:"paths,omitempty" json:"paths,omitempty" m2kpath:"normal"`
	Configs map[ConfigType]interface{} `yaml:"configs,omitempty" json:"configs,omitempty"` // Could be IR or template config or any custom configuration
}

Artifact represents the artifact that can be passed between transformers

func (*Artifact) GetConfig

func (a *Artifact) GetConfig(configName ConfigType, obj interface{}) (err error)

GetConfig returns the config that has a particular config name

type ArtifactProcessConfig

type ArtifactProcessConfig struct {
	Merge    bool                   `yaml:"merge" json:"merge"`
	Mode     ArtifactProcessingMode `yaml:"mode" json:"mode"`
	Disabled bool                   `yaml:"disabled" json:"disabled"` // default is false
}

ArtifactProcessConfig stores config for preprocessing artifact

type ArtifactProcessingMode

type ArtifactProcessingMode string

ArtifactProcessingMode denotes the artifact processing mode

const (
	// Normal denotes normal consumes
	Normal ArtifactProcessingMode = "Normal"
	// MandatoryPassThrough denotes pass through
	MandatoryPassThrough ArtifactProcessingMode = "MandatoryPassThrough"
	// OnDemandPassThrough is generally used for dependencies
	OnDemandPassThrough ArtifactProcessingMode = "OnDemandPassThrough"
)

type ArtifactType

type ArtifactType string

ArtifactType is used to store the artifact type

type Config

type Config interface {
	// Merge helps in merging configs
	Merge(c interface{}) bool
}

Config represents the interface for config functions

type ConfigType

type ConfigType = string

ConfigType is used to store the config type

type DirectoryDetect

type DirectoryDetect struct {
	Levels int `yaml:"levels"` // Supports only 0,1 and -1 currently - default behaviour is -1, when directory detect section is missing
}

DirectoryDetect stores the config on how to iterate over the directories

type InvokedByDefault

type InvokedByDefault struct {
	Enabled bool `yaml:"enabled" json:"enabled"`
}

InvokedByDefault stores config to toggle transformers invoke by default

type PathMapping

type PathMapping struct {
	Type           PathMappingType `yaml:"type,omitempty" json:"type,omitempty"` // Default - Normal copy
	SrcPath        string          `yaml:"sourcePath" json:"sourcePath" m2kpath:"normal"`
	DestPath       string          `yaml:"destinationPath" json:"destinationPath" m2kpath:"normal"` // Relative to output directory
	TemplateConfig interface{}     `yaml:"templateConfig" json:"templateConfig"`
}

PathMapping is the mapping between source and intermediate files and output files

type PathMappingType

type PathMappingType string

PathMappingType refers to the Path Mapping type

const (
	// DefaultPathMappingType allows normal copy with overwrite
	DefaultPathMappingType PathMappingType = "Default" // Normal Copy with overwrite
	// TemplatePathMappingType allows copy of source to destination and applying of template
	TemplatePathMappingType PathMappingType = "Template" // Source path when relative, is relative to yaml file location
	// SourcePathMappingType allows for copying of source directory to another directory
	SourcePathMappingType PathMappingType = "Source" // Source path becomes relative to source directory
	// DeletePathMappingType allows for deleting of files or folder directory
	DeletePathMappingType PathMappingType = "Delete" // Delete path becomes relative to source directory
	// ModifiedSourcePathMappingType allows for copying of deltas wrt source
	ModifiedSourcePathMappingType PathMappingType = "SourceDiff" // Source path becomes relative to source directory
	// PathTemplatePathMappingType allows for path template registration
	PathTemplatePathMappingType PathMappingType = "PathTemplate" // Path Template type
	// SpecialTemplatePathMappingType allows copy of source to destination and applying of template with custom delimiter
	SpecialTemplatePathMappingType PathMappingType = "SpecialTemplate" // Source path when relative, is relative to yaml file location
)

type PathType

type PathType string

PathType is used to store the path type

type ProducedArtifact

type ProducedArtifact struct {
	ChangeTypeTo ArtifactType `yaml:"changeTypeTo" json:"changeTypeTo"`
	Disabled     bool         `yaml:"disabled" json:"disabled"`
}

ProducedArtifact stores config for postprocessing produced artifact

type TransformInput

type TransformInput struct {
	NewArtifacts         []Artifact `yaml:"newArtifacts,omitempty" json:"newArtifacts,omitempty"`
	AlreadySeenArtifacts []Artifact `yaml:"alreadySeenArtifacts,omitempty" json:"alreadySeenArtifacts,omitempty"`
}

TransformInput structure is the input data format for transform functions

type TransformOutput

type TransformOutput struct {
	PathMappings     []PathMapping `yaml:"pathMappings,omitempty" json:"pathMappings,omitempty"`
	CreatedArtifacts []Artifact    `yaml:"artifacts,omitempty" json:"artifacts,omitempty"`
}

TransformOutput structure is the data format for receiving data from starlark transform functions

type Transformer

type Transformer struct {
	types.TypeMeta   `yaml:",inline" json:",inline"`
	types.ObjectMeta `yaml:"metadata,omitempty" json:"metadata,omitempty"`
	Spec             TransformerSpec `yaml:"spec,omitempty" json:"spec,omitempty"`
}

Transformer defines definition of cf runtime instance apps file

func NewTransformer

func NewTransformer() Transformer

NewTransformer creates a new instance of tansformer

type TransformerDisabledError

type TransformerDisabledError struct {
	Err error
}

TransformerDisabledError indicates that the transformer had been intentionally disabled

func (*TransformerDisabledError) Error

func (e *TransformerDisabledError) Error() string

Error implements the interface required for Error

type TransformerSpec

type TransformerSpec struct {
	TransformerYamlPath string                                 `yaml:"-" json:"-"`
	Class               string                                 `yaml:"class" json:"class"`
	Isolated            bool                                   `yaml:"isolated" json:"isolated"`
	DirectoryDetect     DirectoryDetect                        `yaml:"directoryDetect" json:"directoryDetect"`
	ExternalFiles       map[string]string                      `yaml:"externalFiles" json:"externalFiles"` // [source]destination
	ConsumedArtifacts   map[ArtifactType]ArtifactProcessConfig `yaml:"consumes" json:"consumes"`
	ProducedArtifacts   map[ArtifactType]ProducedArtifact      `yaml:"produces" json:"produces"`
	Dependency          interface{}                            `yaml:"dependency" json:"dependency"` // metav1.LabelSelector
	Override            interface{}                            `yaml:"override" json:"override"`     // metav1.LabelSelector
	DependencySelector  labels.Selector                        `yaml:"-" json:"-"`
	OverrideSelector    labels.Selector                        `yaml:"-" json:"-"`
	TemplatesDir        string                                 `yaml:"templates" json:"templates"` // Relative to yaml directory or working directory in image
	Config              interface{}                            `yaml:"config" json:"config"`
	InvokedByDefault    InvokedByDefault                       `yaml:"invokedByDefault" json:"invokedByDefault"`
}

TransformerSpec stores the data