state

type ClientProvider string

type ClientScalingPolicy struct {
	Enabled        bool                    `json:"Enabled"`
	Class          string                  `json:"Class"`
	MinCount       int                     `json:"MinCount"`
	MaxCount       int                     `json:"MaxCount"`
	ScaleOutCount  int                     `json:"ScaleOutCount"`
	ScaleInCount   int                     `json:"ScaleInCount"`
	Provider       ClientProvider          `json:"Provider"`
	ProviderConfig map[string]string       `json:"ProviderConfig"`
	Checks         map[string]*PolicyCheck `json:"Checks"`
}

type ComparisonAction string

type ComparisonOperator string

type Event struct {
	Timestamp int64
	Message   string
	Source    string
}

type EventMessage struct {
	ID        uuid.UUID
	Timestamp int64
	Source    string
	Message   string
	Error     error
}

type PolicyBackend interface {

	// GetPolicies returns all the currently stored policies from the backend. The map is keyed by
	// the class identifier.
	GetPolicies() (map[string]*ClientScalingPolicy, error)

	// GetPolicy takes an input class identifier and returns the scaling policy if it is found
	// within the backend.
	GetPolicy(class string) (*ClientScalingPolicy, error)

	// PutPolicy is used to write a new or update an existing class policy. Updates should
	// overwrite any stored information for the class.
	PutPolicy(policy *ClientScalingPolicy) error

	// DeletePolicy is used to delete the class scaling policy if it exists within the backend
	// storage. If the specified class does not have a policy within the backend, the call will be
	// no-op.
	DeletePolicy(class string) error
}

type PolicyCheck struct {

	// Enabled is a boolean flag to identify whether this specific check should be actively run or
	// not.
	Enabled bool `json:"Enabled"`

	// Resource identifies the Nomad resource which will be checked within this policy check
	// evaluation.
	Resource ScaleResource `json:"Resource"`

	// ComparisonOperator determines how the value if compared to the theshold.
	ComparisonOperator ComparisonOperator `json:"ComparisonOperator"`

	// ComparisonPercentage is the float64 value that will be compared to the result of the metric
	// query.
	ComparisonPercentage float64 `json:"ComparisonPercentage"`

	// Action is the scaling action that should be taken if the queried metric fails the comparison
	// check.
	Action ComparisonAction `json:"Action"`
}

type ScaleBackend interface {

	// GetScalingActivities returns all the currently stored scaling activates from the storage
	// backend. The map is keyed by the scaling ID.
	GetScalingActivities() (map[uuid.UUID]*ScalingActivity, error)

	// GetScalingActivity attempts to retrieve a single scaling activity from the store based on
	// the scaling ID.
	GetScalingActivity(id uuid.UUID) (*ScalingActivity, error)

	// RunStateGarbageCollection triggers a cleanup of the scaling state, removing all entries
	// which are older than the configured threshold.
	RunStateGarbageCollection()

	// WriteRequest is used to write an initial scaling request to the store. This should be called
	// immediately after an activity is requested.
	WriteRequest(req *ScalingRequest) error

	// WriteRequestEvent updates the stored request details with the passed event. This should not
	// overwrite the stored data, but append to the list of stored events.
	WriteRequestEvent(message *ScalingUpdate) error
}

type ScaleDirection string

type ScaleResource string

type ScaleStatus string

type ScalingActivity struct {

	// Events is a list of events which occurred during the scaling operation and provides insight
	// into the operations and actions conducted.
	Events []Event

	// ScaleDirection is the direction of scaling.
	Direction ScaleDirection

	// LastUpdate is the UnixNano timestamp of the last update to the scaling operation and if the
	// status is terminal, indicates the time of the last action of the scaling event.
	LastUpdate int64

	// ScaleStatus indicates the current status of the scaling operation.
	Status ScaleStatus

	// Provider indicated the backend node provider used for this scaling operation.
	Provider ClientProvider

	// ProviderCfg is a key value map containing any runtime specific information for the node
	// provider. This should not include credentials, but instead items such as ASG name,
	// instanceIDs or IP addresses.
	ProviderCfg map[string]string
}

type ScalingRequest struct {
	ID           uuid.UUID
	Direction    ScaleDirection
	TargetNodeID string
	Policy       *ClientScalingPolicy
}

type ScalingUpdate struct {
	ID     uuid.UUID
	Status ScaleStatus
	Detail Event
}