config

Documentation

Index

• Constants
• Variables
• type AutomationResource
• type AutomationType
  • func (AutomationType) ID() TypeId
• type BucketType
  • func (BucketType) ID() TypeId
• type CircularDependencyParameterSortError
  • func (e CircularDependencyParameterSortError) Coordinates() coordinate.Coordinate
  • func (e CircularDependencyParameterSortError) Error() string
  • func (e CircularDependencyParameterSortError) LocationDetails() configErrors.EnvironmentDetails
• type ClassicApiType
  • func (ClassicApiType) ID() TypeId
• type Config
  • func (c *Config) References() []coordinate.Coordinate
  • func (c *Config) Render(properties map[string]interface{}) (string, error)
  • func (c *Config) ResolveParameterValues(entities EntityLookup) (parameter.Properties, []error)
• type EntityLookup
• type EntityType
  • func (EntityType) ID() TypeId
• type Parameters
• type ParamsRefErr
  • func (e ParamsRefErr) Coordinates() coordinate.Coordinate
  • func (e ParamsRefErr) Error() string
  • func (e ParamsRefErr) LocationDetails() configErrors.EnvironmentDetails
• type ResolvedEntity
• type SettingsType
  • func (SettingsType) ID() TypeId
• type Type
• type TypeId

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"
)

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.

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 BucketType

type BucketType struct{}

func (BucketType) ID

func (BucketType) ID() TypeId

type CircularDependencyParameterSortError

type CircularDependencyParameterSortError struct {
	Location           coordinate.Coordinate           `json:"location"`
	EnvironmentDetails configErrors.EnvironmentDetails `json:"environmentDetails"`
	ParameterName      string                          `json:"parameterName"`
	DependsOn          []parameter.ParameterReference  `json:"dependsOn"`
}

func (CircularDependencyParameterSortError) Coordinates

func (e CircularDependencyParameterSortError) Coordinates() coordinate.Coordinate

func (CircularDependencyParameterSortError) Error

func (e CircularDependencyParameterSortError) Error() string

func (CircularDependencyParameterSortError) LocationDetails

func (e CircularDependencyParameterSortError) LocationDetails() configErrors.EnvironmentDetails

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 (*Config) References

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

func (*Config) Render

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

func (*Config) ResolveParameterValues

func (c *Config) ResolveParameterValues(entities EntityLookup) (parameter.Properties, []error)

ResolveParameterValues will resolve the values of all config.Parameters of a config.Config and return them as a parameter.Properties map. Resolving will ensure that parameters are resolved in the right order if they have dependencies between each other. To be able to resolve reference.ReferenceParameter values an EntityLookup needs to be provided, which contains all config.ResolvedEntity values of configurations that the config.Config could depend on. Ordering of configurations to ensure that possible dependency configurations are contained in teh EntityLookup is responsibility of the caller of ResolveParameterValues.

ResolveParameterValues will return a slice of errors for any failures during sorting or resolving parameters.

type EntityLookup

type EntityLookup interface {
	parameter.PropertyResolver

	GetResolvedEntity(config coordinate.Coordinate) (ResolvedEntity, bool)
}

EntityLookup is used in parameter resolution to fetch the resolved entity of deployed configuration

type EntityType

type EntityType struct {
	EntitiesType string
}

func (EntityType) ID

func (EntityType) ID() TypeId

type Parameters

type Parameters map[string]parameter.Parameter

Parameters defines a map of name to parameter

type ParamsRefErr

type ParamsRefErr struct {
	Location           coordinate.Coordinate           `json:"location"`
	EnvironmentDetails configErrors.EnvironmentDetails `json:"environmentDetails"`
	ParameterName      string                          `json:"parameterName"`
	Reference          parameter.ParameterReference    `json:"parameterReference"`
	Reason             string                          `json:"reason"`
}

func (ParamsRefErr) Coordinates

func (e ParamsRefErr) Coordinates() coordinate.Coordinate

func (ParamsRefErr) Error

func (e ParamsRefErr) Error() string

func (ParamsRefErr) LocationDetails

func (e ParamsRefErr) LocationDetails() configErrors.EnvironmentDetails

type ResolvedEntity

type ResolvedEntity struct {
	// EntityName is the name returned by the Dynatrace api. In theory should be the
	// same as the `name` property defined in the configuration, but
	// can differ.
	EntityName string

	// Coordinate of the config.Config this entity represents
	Coordinate coordinate.Coordinate

	// Properties defines a map of all already resolved parameters
	Properties parameter.Properties

	// Skip flag indicating that this entity was skipped
	// if an entity is skipped, there will be no properties
	Skip bool
}

ResolvedEntity represents the Dynatrace configuration entity of a config.Config

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"
	BucketTypeId     TypeId = "bucket"
)