config

Documentation

Index

• Constants
• Variables
• func WriteConfigs(context *WriterContext, configs []Config) []error
• type AutomationResource
• type AutomationType
  • func (AutomationType) ID() TypeId
• type ClassicApiType
  • func (ClassicApiType) ID() TypeId
• type Config
  • func LoadConfigs(fs afero.Fs, context *LoaderContext) (result []Config, errors []error)
  • func (c *Config) References() []coordinate.Coordinate
  • func (c *Config) Render(properties map[string]interface{}) (string, error)
• type EntityType
  • func (EntityType) ID() TypeId
• type LoaderContext
• type Parameters
• type References
• type SettingsType
  • func (SettingsType) ID() TypeId
• 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 WriteConfigs

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

Types

type AutomationResource

type AutomationResource string

AutomationResource defines which resource is an AutomationType

const (
	Workflow         AutomationResource = "workflow"
	BusinessCalendar AutomationResource = "business-calendar"
	SchedulingRule   AutomationResource = "scheduling-rule"
)

type AutomationType

type AutomationType struct {
	// Resource identifies which Automation resource is used in this config.
	// Currently, this can be Workflow, BusinessCalendar, or SchedulingRule.
	Resource AutomationResource
}

AutomationType represents any Dynatrace Platform automation-resource

func (AutomationType) ID

func (AutomationType) ID() TypeId

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
	// 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) References

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

func (*Config) Render

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

type EntityType

type EntityType struct {
	EntitiesType 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
}

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 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"
	AutomationTypeId TypeId = "automation"
)

type WriterContext

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