sdk

type FileDecodePolicyCheckDoc struct {
	Name                 string `hcl:"name,label"`
	Group                string `hcl:"group,optional"`
	Source               string `hcl:"source,optional"`
	Query                string `hcl:"query,optional"`
	QueryWindow          time.Duration
	QueryWindowHCL       string `hcl:"query_window,optional"`
	QueryWindowOffset    time.Duration
	QueryWindowOffsetHCL string                 `hcl:"query_window_offset,optional"`
	OnError              string                 `hcl:"on_error,optional"`
	Strategy             *ScalingPolicyStrategy `hcl:"strategy,block"`
}

type FileDecodePolicyDoc struct {
	Cooldown              time.Duration
	CooldownHCL           string `hcl:"cooldown,optional"`
	EvaluationInterval    time.Duration
	EvaluationIntervalHCL string                      `hcl:"evaluation_interval,optional"`
	OnCheckError          string                      `hcl:"on_check_error,optional"`
	Checks                []*FileDecodePolicyCheckDoc `hcl:"check,block"`
	Target                *ScalingPolicyTarget        `hcl:"target,block"`
}

type FileDecodeScalingPolicies struct {
	ScalingPolicies []*FileDecodeScalingPolicy `hcl:"scaling,block"`
}

type FileDecodeScalingPolicy struct {
	Name    string               `hcl:"name,label"`
	Enabled bool                 `hcl:"enabled,optional"`
	Type    string               `hcl:"type,optional"`
	Min     int64                `hcl:"min,optional"`
	Max     int64                `hcl:"max"`
	Doc     *FileDecodePolicyDoc `hcl:"policy,block"`
}

type ScaleDirection int8

type ScalingAction struct {

	// Count represents the desired count of the target resource. It should
	// always be zero or above, expect in the event of dry-run where it can use
	// the StrategyActionMetaValueDryRunCount value.
	Count int64

	// Reason is the top level string that provides a user friendly description
	// of why the strategy decided the action was required.
	Reason string

	// Error indicates whether the Reason string is an error condition. This
	// allows the Reason to be flexible in its use.
	Error bool

	// Direction is the scaling direction the strategy has decided should
	// happen. This is particularly helpful for non-Nomad target
	// implementations whose APIs dead with increment changes rather than
	// absolute counts.
	Direction ScaleDirection

	// Meta
	Meta map[string]interface{}
}

type ScalingCheckEvaluation struct {

	// Check is the individual ScalingPolicyCheck that this eval is concerned
	// with.
	Check *ScalingPolicyCheck

	// Metrics is the metric resulting from querying the APM.
	Metrics TimestampedMetrics

	// Action is the calculated desired state and is populated by strategy.Run.
	Action *ScalingAction
}

type ScalingEvaluation struct {
	ID               string
	Policy           *ScalingPolicy
	CheckEvaluations []*ScalingCheckEvaluation
	CreateTime       time.Time
}

type ScalingPolicy struct {

	// ID is a UUID which uniquely identifies this scaling policy. Depending on
	// the policy source this will be sourced in different manners.
	ID string

	// Type is the type of scaling this policy will perform.
	Type string

	// Priority controls the order in which a policy is picked for evaluation.
	Priority int

	// Min forms a lower bound at which the target should never be asked to
	// break. The autoscaler will actively adjust recommendations to ensure
	// this value is not violated.
	Min int64

	// Max forms an upper bound at which the target should never be asked to
	// exceed. The autoscaler will actively adjust recommendations to ensure
	// this value is not violated.
	Max int64

	// Enabled indicates whether the autoscaler should actively evaluate the
	// policy or not.
	Enabled bool

	// OnCheckError defines how errors are handled by the Autoscaler when
	// running the policy checks. Possible values are "ignore" or "fail".
	//
	// If "ignore" the policy evaluation will continue even if a check fails.
	// If "fail" the the entire policy evaluation will stop and no action will
	// be taken.
	OnCheckError string

	// Cooldown is the time period after a scaling action if performed, during
	// which no policy evaluations will be started.
	Cooldown time.Duration

	// EvaluationInterval indicates the frequency at which the policy is
	// evaluated. A lower value means more frequent evaluation and can result
	// in a high rate of change in the target.
	EvaluationInterval time.Duration

	// Checks is an array of checks which will be triggered in parallel to
	// determine the desired state of the ScalingPolicyTarget.
	Checks []*ScalingPolicyCheck

	// Target identifies the scaling target which the autoscaler will interact
	// with to ensure it meets the desired state as determined by the Checks.
	Target *ScalingPolicyTarget
}

type ScalingPolicyCheck struct {

	// Name is a human readable name for this check and allows operators to
	// create clearly identified policy checks.
	Name string

	// Group is used to group related checks together. Their results will be
	// consolidated into a single action.
	Group string

	// Source is the APM plugin that should be used to perform the query and
	// obtain the metric that will be used to perform a calculation.
	Source string

	// Query is run against the Source in order to receive a metric response.
	Query string

	// QueryWindow is used to define how further back in time to query for
	// metrics.
	QueryWindow time.Duration

	// QueryWindowOffset defines an offset from the current time to apply to
	// the query window.
	QueryWindowOffset time.Duration

	// Strategy is the ScalingPolicyStrategy to use when performing the
	// ScalingPolicyCheck evaluation.
	Strategy *ScalingPolicyStrategy

	// OnError defines how errors are handled by the Autoscaler when running
	// this check. Possible values are "ignore" or "fail". If not set the
	// policy `on_check_error` value will be used.
	//
	// If "ignore" the check is not considered when calculating the final
	// scaling action result.
	// If "fail" the the entire policy evaluation will stop and no action will
	// be taken.
	OnError string
}

type ScalingPolicyStrategy struct {

	// Name is the strategy that will be used to perform the desired state
	// calculation.
	Name string `hcl:"name,label"`

	// Config is the mapping of config values used by the strategy plugin. Each
	// plugin has a set of potentially uniquely supported keys.
	Config map[string]string `hcl:",remain"`
}

type ScalingPolicyTarget struct {

	// Name identifies the target plugin which can handle performing target
	// requests for this ScalingPolicy.
	Name string `hcl:"name,label"`

	// Config is the mapping of config values used by the target plugin. Each
	// plugin has a set of potentially uniquely supported keys.
	Config map[string]string `hcl:",remain"`
}

type TargetScalingNoOpError struct {
	Err error
}

type TargetStatus struct {

	// Ready indicates whether the target is currently in a state where scaling
	// is permitted.
	Ready bool

	// Count is the current value of the target and thus performs the current
	// state basis when performing strategy calculations to identify the
	// desired state.
	Count int64

	// Meta is a mapping that provides additional information about the target
	// that can be used during the policy evaluation to ensure the correct
	// calculations and logic are applied to the target.
	Meta map[string]string
}

type TimeRange struct {
	From time.Time
	To   time.Time
}

type TimestampedMetric struct {
	Timestamp time.Time
	Value     float64
}

type TimestampedMetrics []TimestampedMetric