v2

Documentation

Index

• Constants
• Variables
• func Sanitize(name string) string
• func WriteConfigs(context *WriterContext, configs []Config) []error
• type ClassicApiType
  • func (ClassicApiType) ID() TypeId
• type Config
  • func LoadConfigs(fs afero.Fs, context *LoaderContext) (result []Config, errors []error)
  • func (c *Config) LoadPaddedTemplateBytes(prefix []byte, suffix []byte) ([]byte, error)
  • func (c *Config) LoadTemplateBytes() ([]byte, error)
  • func (c *Config) References() []coordinate.Coordinate
  • func (c *Config) Render(properties map[string]interface{}) (string, error)
• type ConfigLoaderContext
• type DefinitionParserError
  • func (e DefinitionParserError) Coordinates() coordinate.Coordinate
  • func (e DefinitionParserError) Error() string
• type DetailedDefinitionParserError
  • func (e DetailedDefinitionParserError) Environment() string
  • func (e DetailedDefinitionParserError) LocationDetails() configErrors.EnvironmentDetails
• type EntityType
  • func (EntityType) ID() TypeId
• type LoaderContext
• type ParameterDefinitionParserError
  • func (e ParameterDefinitionParserError) Error() string
• type Parameters
• type References
• type SettingsType
  • func (SettingsType) ID() TypeId
• type SingleConfigLoadContext
• type Type
• type TypeId
• type WriterContext

Constants

const (
	// IdParameter is special. it is not allowed to be set via the config,
	// but needs to work as normal parameter otherwise (e.g. it can be referenced).
	IdParameter = "id"

	// NameParameter is special in that it needs to exist for a config.
	NameParameter = "name"

	// ScopeParameter is special. It is the set scope as a parameter.
	// A user must not set it as a parameter in the config.
	// It is only a parameter iff the config is a settings-config.
	ScopeParameter = "scope"

	// SkipParameter is special in that config should be deployed or not
	SkipParameter = "skip"
)

const MaxFilenameLengthWithoutFileExtension = 254

Variables

var DefaultParameterParsers = map[string]parameter.ParameterSerDe{
	refParam.ReferenceParameterType:           refParam.ReferenceParameterSerde,
	valueParam.ValueParameterType:             valueParam.ValueParameterSerde,
	envParam.EnvironmentVariableParameterType: envParam.EnvironmentVariableParameterSerde,
	compoundParam.CompoundParameterType:       compoundParam.CompoundParameterSerde,
	listParam.ListParameterType:               listParam.ListParameterSerde,
}

DefaultParameterParsers map defining a set of default parsers which can be used to load configurations

var ReservedParameterNames = []string{IdParameter, NameParameter, ScopeParameter, SkipParameter}

ReservedParameterNames holds all parameter names that may not be specified by a user in a config.

Functions

func Sanitize

func Sanitize(name string) string

Sanitize removes special characters, limits to max 254 characters in name, no special characters except '-', '_', and '.'

func WriteConfigs

func WriteConfigs(context *WriterContext, configs []Config) []error

Types

type ClassicApiType

type ClassicApiType struct {
	Api string
}

func (ClassicApiType) ID

func (ClassicApiType) ID() TypeId

type Config

type Config struct {
	// template used to render the request send to the dynatrace api
	Template     template.Template
	TemplatePath string
	// coordinates which specify the location of this configuration
	Coordinate coordinate.Coordinate
	// group this config belongs to
	Group string
	// name of the environment this configuration is for
	Environment string
	// Type holds information of the underlying config type (classic, settings, entities)
	Type Type
	// map of all parameters which will be resolved and are then available
	// in the template
	Parameters Parameters

	// Skip flag indicates if the deployment of this configuration should be skipped. It is resolved during project loading.
	Skip bool

	// SkipForConversion is only used for converting v1-configs to v2-configs.
	// It is required as the object itself does only store the resolved 'skip' value, not the actual parameter.
	SkipForConversion parameter.Parameter

	// OriginObjectId is the DT object ID of the object when it was downloaded from an environment
	OriginObjectId string
}

Config struct defining a configuration which can be deployed.

func LoadConfigs

func LoadConfigs(fs afero.Fs, context *LoaderContext) (result []Config, errors []error)

LoadConfigs will search a given path for configuration yamls and parses them. It will try to parse all configurations it finds and returns a list of parsed configs. If any error was encountered, the list of configs will be nil and only the error slice will be filled.

func (*Config) LoadPaddedTemplateBytes

func (c *Config) LoadPaddedTemplateBytes(prefix []byte, suffix []byte) ([]byte, error)

func (*Config) LoadTemplateBytes

func (c *Config) LoadTemplateBytes() ([]byte, error)

func (*Config) References

func (c *Config) References() []coordinate.Coordinate

func (*Config) Render

func (c *Config) Render(properties map[string]interface{}) (string, error)

type ConfigLoaderContext

type ConfigLoaderContext struct {
	*LoaderContext
	Folder string
	Path   string
}

type DefinitionParserError

type DefinitionParserError struct {
	Location coordinate.Coordinate
	Path     string
	Reason   string
}

func (DefinitionParserError) Coordinates

func (e DefinitionParserError) Coordinates() coordinate.Coordinate

func (DefinitionParserError) Error

func (e DefinitionParserError) Error() string

type DetailedDefinitionParserError

type DetailedDefinitionParserError struct {
	DefinitionParserError
	EnvironmentDetails configErrors.EnvironmentDetails
}

func (DetailedDefinitionParserError) Environment

func (e DetailedDefinitionParserError) Environment() string

func (DetailedDefinitionParserError) LocationDetails

func (e DetailedDefinitionParserError) LocationDetails() configErrors.EnvironmentDetails

type EntityType

type EntityType struct {
	EntitiesType string
	From         string
	To           string
}

func (EntityType) ID

func (EntityType) ID() TypeId

type LoaderContext

type LoaderContext struct {
	ProjectId         string
	Path              string
	Environments      []manifest.EnvironmentDefinition
	KnownApis         map[string]struct{}
	ParametersSerDe   map[string]parameter.ParameterSerDe
	ProjectWorkingDir string
}

type ParameterDefinitionParserError

type ParameterDefinitionParserError struct {
	DetailedDefinitionParserError
	ParameterName string
}

func (ParameterDefinitionParserError) Error

func (e ParameterDefinitionParserError) Error() string

type Parameters

type Parameters map[string]parameter.Parameter

Parameters defines a map of name to parameter

type References

type References map[string]coordinate.Coordinate

References holds coordinate-string -> coordinate

type SettingsType

type SettingsType struct {
	SchemaId, SchemaVersion string
}

func (SettingsType) ID

func (SettingsType) ID() TypeId

type SingleConfigLoadContext

type SingleConfigLoadContext struct {
	*ConfigLoaderContext
	Type string
}

type Type

type Type interface {
	// ID returns the type-id.
	ID() TypeId
}

type TypeId

type TypeId string

const (
	SettingsTypeId   TypeId = "settings"
	ClassicApiTypeId TypeId = "classic"
	EntityTypeId     TypeId = "entity"
)

type WriterContext

type WriterContext struct {
	Fs              afero.Fs
	OutputFolder    string
	ProjectFolder   string
	ParametersSerde map[string]parameter.ParameterSerDe
}