chaosmonkey

type AppConfig struct {
	Enabled                        bool
	RegionsAreIndependent          bool
	MeanTimeBetweenKillsInWorkDays int
	MinTimeBetweenKillsInWorkDays  int
	Grouping                       Group
	Exceptions                     []Exception
	Whitelist                      *[]Exception
}

type AppConfigGetter interface {
	// Get returns the App config info by app name
	Get(app string) (*AppConfig, error)
}

type Checker interface {
	// Check checks if a termination is permitted and, if so, records the
	// termination time on the server.
	// The endHour (hour time when Chaos Monkey stops killing) is in the
	// time zone specified by loc.
	Check(term Termination, appCfg AppConfig, endHour int, loc *time.Location) error
}

type Decryptor interface {
	Decrypt(ciphertext string) (string, error)
}

type Env interface {
	// InTest returns true if Chaos Monkey is running in a test environment
	InTest() bool
}

type ErrViolatesMinTime struct {
	InstanceID string         // the most recent terminated instance id
	KilledAt   time.Time      // the time that the most recent instance was terminated
	Loc        *time.Location // local time zone location
}

type ErrorCounter interface {
	Increment() error
}

type Exception struct {
	Account string
	Stack   string
	Detail  string
	Region  string
}

type Group int

type Instance interface {
	// AppName is the name of the Netflix app
	AppName() string

	// AccountName is the name of the account the instance is running in (e.g., prod, test)
	AccountName() string

	// RegionName is the name of the AWS region (e.g., us-east-1
	RegionName() string

	// StackName returns the "stack" part of app-stack-detail in cluster names
	StackName() string

	// ClusterName is the full cluster name: app-stack-detail
	ClusterName() string

	// ASGName is the name of the ASG associated with the instance
	ASGName() string

	// ID is the instance ID, e.g. i-dbcba24c
	ID() string

	// CloudProvider returns the cloud provider (e.g., "aws")
	CloudProvider() string
}

type Outage interface {
	// Outage returns true if there is an ongoing outage
	Outage() (bool, error)
}

type Termination struct {
	Instance Instance  // The instance that will be terminated
	Time     time.Time // Termination time
	Leashed  bool      // If true, track the termination but do not execute it
}

type Terminator interface {
	// Kill terminates a running instance
	Execute(trm Termination) error
}

type Tracker interface {
	// Track pushes a termination event to the tracking system
	Track(t Termination) error
}