cocoa

type AWSVPCOptions struct {
	// Subnets are all the subnet IDs associated with the pod. This is required.
	Subnets []string
	// SecurityGroups are all the security group IDs associated with the pod. If
	// this is not specified, the default security group for the VPC will be
	// used.
	SecurityGroups []string
}

type ContainerSecret struct {
	// ID is the unique resource identifier for the secret.
	ID *string
	// Name is the friendly name of the secret.
	Name *string
	// Owned determines whether or not the secret is owned by its container or
	// not.
	Owned *bool
}

type ECSClient interface {
	// RegisterTaskDefinition registers the definition for a new task with ECS.
	RegisterTaskDefinition(context.Context, *ecs.RegisterTaskDefinitionInput) (*ecs.RegisterTaskDefinitionOutput, error)
	// DescribeTaskDefinitions gets information about the configuration and
	// status of a task definition.
	DescribeTaskDefinition(ctx context.Context, in *ecs.DescribeTaskDefinitionInput) (*ecs.DescribeTaskDefinitionOutput, error)
	// ListTaskDefinitions lists all ECS task definitions matching the input.
	ListTaskDefinitions(ctx context.Context, in *ecs.ListTaskDefinitionsInput) (*ecs.ListTaskDefinitionsOutput, error)
	// DeregisterTaskDefinition deregisters an existing ECS task definition.
	DeregisterTaskDefinition(ctx context.Context, in *ecs.DeregisterTaskDefinitionInput) (*ecs.DeregisterTaskDefinitionOutput, error)
	// RunTask runs a registered task.
	RunTask(ctx context.Context, in *ecs.RunTaskInput) (*ecs.RunTaskOutput, error)
	// DescribeTasks gets information about the configuration and status of
	// tasks.
	DescribeTasks(ctx context.Context, in *ecs.DescribeTasksInput) (*ecs.DescribeTasksOutput, error)
	// ListTasks lists all ECS tasks matching the input.
	ListTasks(ctx context.Context, in *ecs.ListTasksInput) (*ecs.ListTasksOutput, error)
	// StopTask stops a running task.
	StopTask(ctx context.Context, in *ecs.StopTaskInput) (*ecs.StopTaskOutput, error)
	// TagResource adds tags to an ECS resource.
	TagResource(ctx context.Context, in *ecs.TagResourceInput) (*ecs.TagResourceOutput, error)
	// Close closes the client and cleans up its resources. Implementations
	// should ensure that this is idempotent.
	Close(ctx context.Context) error
}

type ECSContainerDefinition struct {
	// Name is the friendly name of the container. By default, this is a random
	// string.
	Name *string
	// Image is the Docker image to use. This is required.
	Image *string
	// Command is the command to run, separated into individual arguments. By
	// default, there is no command.
	Command []string
	// WorkingDir is the container working directory in which commands will be
	// run.
	WorkingDir *string
	// MemoryMB is the amount of memory (in MB) to allocate. This must be set if
	// a pod-level memory limit is not given.
	MemoryMB *int
	// CPU is the number of CPU units to allocate. 1024 CPU units is equivalent
	// to 1 vCPU on a machine. This must be set if a pod-level CPU limit is not
	// given.
	CPU *int
	// EnvVars are environment variables to make available in the container.
	EnvVars []EnvironmentVariable
	// RepoCreds are private repository credentials for using images that
	// require authentication.
	RepoCreds *RepositoryCredentials
	// PortMappings are mappings between the ports within the container to
	// allow network traffic.
	PortMappings []PortMapping
	// LogConfiguration is the configuration for logging the container's output.
	LogConfiguration *LogConfiguration
}

type ECSContainerResources struct {
	// ContainerID is the resource identifier for the container.
	ContainerID *string `bson:"-" json:"-" yaml:"-"`
	// Name is the friendly name of the container.
	Name *string `bson:"-" json:"-" yaml:"-"`
	// Secrets are the secrets associated with the container.
	Secrets []ContainerSecret `bson:"-" json:"-" yaml:"-"`
}

type ECSContainerStatusInfo struct {
	// ContainerID is the resource identifier for the container.
	ContainerID *string
	// Name is the friendly name of the container.
	Name *string
	// Status is the current status of the container.
	Status ECSStatus
}

type ECSNetworkMode string

type ECSOverrideContainerDefinition struct {
	// Name is the friendly name of the container whose options should be
	// overridden. This is required.
	Name *string
	// Command is the command to run, overriding any existing container command.
	Command []string
	// MemoryMB is the amount of memory (in MB) to allocate.
	MemoryMB *int
	// CPU is the number of CPU units to allocate.
	CPU *int
	// EnvVars are the environment variables to override for this container. If
	// there is an existing environment variable with the same name, it is
	// overridden; otherwise, the environment variable is appended to the
	// existing ones.
	EnvVars []KeyValue
}

type ECSOverridePodDefinitionOptions struct {
	// ContainerDefinitions defines settings that apply to individual containers
	// within the pod.
	ContainerDefinitions []ECSOverrideContainerDefinition
	// MemoryMB overrides the pod definition's hard memory limit (in MB) across
	// all containers in the pod. This is ignored for pods running Windows
	// containers.
	MemoryMB *int
	// CPU overrides the pod definition's hard CPU limit (in CPU units) across
	// all containers in the pod. 1024 CPU units is equivalent to 1 vCPU on a
	// machine. This is ignored for pods running Windows containers.
	CPU *int
	// TaskRole overrides the task role that the pod can use.
	TaskRole *string
	// ExecutionRole overrides the execution role that ECS container agent can
	// use.
	ExecutionRole *string
}

type ECSPlacementStrategy string

type ECSPod interface {
	// Resources returns information about the current resources being used by
	// the pod.
	Resources() ECSPodResources
	// StatusInfo returns the current cached status information for the pod.
	StatusInfo() ECSPodStatusInfo
	// LatestStatusInfo returns the latest non-cached status information for the
	// pod. Implementations should query ECS directly for its most up-to-date
	// status.
	LatestStatusInfo(ctx context.Context) (*ECSPodStatusInfo, error)
	// Stop stops the running pod without cleaning up any of its underlying
	// resources.
	Stop(ctx context.Context) error
	// Delete deletes the pod and its owned resources.
	Delete(ctx context.Context) error
}

type ECSPodCreationOptions struct {
	// DefinitionOpts specify options to configure the pod's definition.
	DefinitionOpts ECSPodDefinitionOptions
	// ExecutionOpts specify options to configure how the pod executes.
	ExecutionOpts *ECSPodExecutionOptions
}

type ECSPodCreator interface {
	// CreatePod creates a new pod backed by ECS with the given options. Options
	// are applied in the order they're specified and conflicting options are
	// overwritten.
	CreatePod(ctx context.Context, opts ...ECSPodCreationOptions) (ECSPod, error)
	// CreatePodFromExistingDefinition creates a new pod backed by ECS from an
	// existing task definition.
	CreatePodFromExistingDefinition(ctx context.Context, def ECSTaskDefinition, opts ...ECSPodExecutionOptions) (ECSPod, error)
}

type ECSPodDefinitionCache interface {
	// Put adds a new pod definition item or or updates an existing pod
	// definition item.
	Put(ctx context.Context, item ECSPodDefinitionItem) error
	// Delete deletes by its unique identifier in ECS.
	Delete(ctx context.Context, id string) error
	// GetTag returns the name of the tracking tag to use for the pod
	// definition. Implementations are allowed to return an empty string.
	GetTag() string
}

type ECSPodDefinitionItem struct {
	// ID is the unique identifier in ECS for pod definition represented by the
	// item.
	ID string
	// DefinitionOpts are the options used to create the pod definition.
	DefinitionOpts ECSPodDefinitionOptions
}

type ECSPodDefinitionManager interface {
	// CreatePodDefinition creates a pod definition.
	CreatePodDefinition(ctx context.Context, opts ...ECSPodDefinitionOptions) (*ECSPodDefinitionItem, error)
	// DeletePodDefinition deletes an existing pod definition. Implementations
	// should ensure that deletion is idempotent.
	DeletePodDefinition(ctx context.Context, id string) error
}

type ECSPodDefinitionOptions struct {
	// Name is the friendly name of the pod. By default, this is a random
	// string.
	Name *string
	// ContainerDefinitions defines settings that apply to individual containers
	// within the pod. This is required.
	ContainerDefinitions []ECSContainerDefinition
	// MemoryMB is the hard memory limit (in MB) across all containers in the
	// pod. If this is not specified, then each container is required to specify
	// its own memory. This is ignored for pods running Windows containers.
	MemoryMB *int
	// CPU is the hard CPU limit (in CPU units) across all containers in the
	// pod. 1024 CPU units is equivalent to 1 vCPU on a machine. If this is not
	// specified, then each container is required to specify its own CPU.
	// This is ignored for pods running Windows containers.
	CPU *int
	// NetworkMode describes the networking capabilities of the pod's
	// containers. If the NetworkMode is unspecified for a pod running Linux
	// containers, the default value is NetworkModeBridge. If the NetworkMode is
	// unspecified for a pod running Windows containers, the default network
	// mode is to use the Windows NAT network.
	NetworkMode *ECSNetworkMode
	// TaskRole is the role that the pod can use. Depending on the
	// configuration, this may be required if
	// (ECSPodExecutionOptions).SupportsDebugMode is true.
	TaskRole *string
	// ExecutionRole is the role that ECS container agent can use. Depending on
	// the configuration, this may be required if the container uses secrets.
	ExecutionRole *string
	// Tags are resource tags to apply to the pod definition.
	Tags map[string]string
}

type ECSPodExecutionOptions struct {
	// Cluster is the name of the cluster where the pod will run. If none is
	// specified, this will run in the default cluster.
	Cluster *string
	// CapacityProvider is the name of the capacity provider that the pod will
	// use, which in turn determines the infrastructure that the pod will run
	// on. If none is specified, this will run in the default capacity provider.
	CapacityProvider *string
	// OverrideOpts specify options that override the settings in the pod's
	// definition.
	// Warning: the size of the options when serialized to JSON cannot exceed 8
	// kB, so care should be taken to not rely too heavily on overriding the
	// pod definition's settings.
	OverrideOpts *ECSOverridePodDefinitionOptions
	// PlacementOptions specify options that determine how a pod is assigned to
	// a container instance.
	PlacementOpts *ECSPodPlacementOptions
	// AWSVPCOpts specify additional networking configuration when using
	// NetworkModeAWSVPC.
	AWSVPCOpts *AWSVPCOptions
	// SupportsDebugMode indicates that the ECS pod should support debugging, so
	// you can run exec in the pod's containers. In order for this to work, the
	// pod must have the correct permissions to perform this operation when it's
	// defined. By default, this is false.
	SupportsDebugMode *bool
	// Tags are any tags to apply to the running pods.
	Tags map[string]string
}

type ECSPodPlacementOptions struct {
	// Group is the name of a logical collection of ECS pods. Pods within the
	// same group can support additional placement configuration.
	Group *string

	// Strategy is the overall placement strategy. By default, it uses the
	// binpack strategy.
	Strategy *ECSPlacementStrategy

	// StrategyParameter is the parameter that determines how the placement
	// strategy optimizes pod placement. The default value depends on the
	// strategy:
	// If the strategy is spread, it defaults to "host".
	// If the strategy is binpack, it defaults to "memory".
	// If the strategy is random, this does not apply.
	StrategyParameter *ECSStrategyParameter

	// InstanceFilter is a set of query expressions that restrict the placement
	// of the pod to a set of container instances in the cluster that match the
	// query filter. As a special case, if ConstraintDistinctInstance is the
	// specified filter, it will place each pod in the pod's group on a
	// different instance. Otherwise, all filters are assumed to use the ECS
	// cluster query language to filter the candidate set of instances for a
	// pod. Docs:
	// https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cluster-query-language.html
	InstanceFilters []string
}

type ECSPodResources struct {
	// TaskID is the resource identifier for the pod.
	TaskID *string `bson:"-" json:"-" yaml:"-"`
	// TaskDefinition is the resource identifier for the definition template
	// that created the pod.
	TaskDefinition *ECSTaskDefinition `bson:"-" json:"-" yaml:"-"`
	// Cluster is the name of the cluster namespace in which the pod is running.
	Cluster *string `bson:"-" json:"-" yaml:"-"`
	// Containers represent the resources associated with each individual
	// container in the pod.
	Containers []ECSContainerResources `bson:"-" json:"-" yaml:"-"`
}

type ECSPodStatusInfo struct {
	// Status is the status of the pod as a whole.
	Status ECSStatus `bson:"-" json:"-" yaml:"-"`
	// Containers represent the status information of the individual containers
	// within the pod.
	Containers []ECSContainerStatusInfo `bson:"-" json:"-" yaml:"-"`
}

type ECSStatus string

type ECSStrategyParameter = string

type ECSTaskDefinition struct {
	// ID is the ID of the task definition, which should already exist.
	ID *string
	// Owned determines whether or not the task definition is owned by its pod
	// or not.
	Owned *bool
}

type ECSTaskNotFoundError struct {
	ARN string
}

type EnvironmentVariable struct {
	// KeyValue represents the environment variable's name and plaintext value.
	// The plaintext value is required if SecretOpts is not given.
	KeyValue
	// SecretOpts are options to define a stored secret that the environment
	// variable refers to. This is required if the non-secret Value is not
	// given.
	SecretOpts *SecretOptions
}

type KeyValue struct {
	// Name is the name of the key-value pair.
	Name *string
	// Value is the plaintext value associated with the name.
	Value *string
}

type LogConfiguration struct {
	// LogDriver is the logging driver to use.
	LogDriver *string
	// Options are the logging driver options.
	Options map[string]string
}

type NamedSecret struct {
	// Name is either the friendly human-readable name to assign to the secret
	// or the resource identifier if the secret already exists.
	Name *string
	// Value is the stored value of the secret.
	Value *string
}

type PortMapping struct {
	// ContainerPort is the port within the container to expose to network
	// traffic.
	ContainerPort *int
	// HostPort is the port within the container instance to which the container
	// port will be bound.
	// If the pod's network mode is NetworkModeAWSVPC or NetworkModeHost, then
	// this will be set to the same value as ContainerPort.
	// If the pod's network mode is NetworkModeBridge, this can either be
	// explicitly set or omitted to be assigned a port at random.
	HostPort *int
}

type RepositoryCredentials struct {
	// ID is the unique resource identifier for an existing secret containing
	// the credentials for a private repository.
	ID *string
	// Name is the friendly name of the secret containing the credentials
	// for a private repository.
	Name *string
	// NewCreds are the new credentials to be stored. If this is unspecified,
	// the secrets are assumed to already exist.
	NewCreds *StoredRepositoryCredentials
	// Owned determines whether or not the secret is owned by its pod or not.
	Owned *bool
}

type SecretCache interface {
	// Put adds a new secret with the given name and external resource
	// identifier in the cache.
	Put(ctx context.Context, item SecretCacheItem) error
	// Delete deletes an existing secret with the given external resource
	// identifier from the cache.
	Delete(ctx context.Context, id string) error
	// GetTag returns the name of the tracking tag to use for the secret.
	// Implementations are allowed to return an empty string.
	GetTag() string
}

type SecretCacheItem struct {
	// ID is the unique resource identifier for the stored secret.
	ID string
	// Name is the friendly name of the secret.
	Name string
}

type SecretOptions struct {
	// ID is the unique resource identfier for an existing secret.
	ID *string
	// Name is the friendly name of the secret.
	Name *string
	// NewValue is the value of the secret if it must be created.
	NewValue *string
	// Owned determines whether or not the secret is owned by its container or
	// not.
	Owned *bool
}

type SecretsManagerClient interface {
	// CreateSecret creates a new secret.
	CreateSecret(ctx context.Context, in *secretsmanager.CreateSecretInput) (*secretsmanager.CreateSecretOutput, error)
	// GetSecretValue gets the decrypted value of a secret.
	GetSecretValue(ctx context.Context, in *secretsmanager.GetSecretValueInput) (*secretsmanager.GetSecretValueOutput, error)
	// DescribeSecret gets metadata information about a secret.
	DescribeSecret(ctx context.Context, in *secretsmanager.DescribeSecretInput) (*secretsmanager.DescribeSecretOutput, error)
	// ListSecrets lists all metadata information for secrets matching the
	// filters.
	ListSecrets(ctx context.Context, in *secretsmanager.ListSecretsInput) (*secretsmanager.ListSecretsOutput, error)
	// UpdateSecret updates the value of an existing secret.
	UpdateSecretValue(ctx context.Context, in *secretsmanager.UpdateSecretInput) (*secretsmanager.UpdateSecretOutput, error)
	// DeleteSecret deletes an existing secret.
	DeleteSecret(ctx context.Context, in *secretsmanager.DeleteSecretInput) (*secretsmanager.DeleteSecretOutput, error)
	// TagResource adds tags to an existing secret.
	TagResource(ctx context.Context, in *secretsmanager.TagResourceInput) (*secretsmanager.TagResourceOutput, error)
	// Close closes the client and cleans up its resources. Implementations
	// should ensure that this is idempotent.
	Close(ctx context.Context) error
}

type StoredRepositoryCredentials struct {
	// Username is the username for authentication.
	Username *string `json:"username"`
	// Password is the password for authentication.
	Password *string `json:"password"`
}

type TagClient interface {
	// GetResources lists arbitrary AWS resources matching the input.
	GetResources(ctx context.Context, in *resourcegroupstaggingapi.GetResourcesInput) (*resourcegroupstaggingapi.GetResourcesOutput, error)
	// Close closes the client and cleans up its resources. Implementations
	// should ensure that this is idempotent.
	Close(ctx context.Context) error
}

type Vault interface {
	// CreateSecret creates a new secret and returns the unique identifier for
	// the stored secret. If the secret already exists, it just returns the
	// unique identifier for the existing secret without modifying its value. To
	// update the secret's value, see UpdateValue.
	CreateSecret(ctx context.Context, s NamedSecret) (id string, err error)
	// GetValue returns the value of the secret identified by ID.
	GetValue(ctx context.Context, id string) (val string, err error)
	// UpdateValue updates an existing secret's value by ID.
	UpdateValue(ctx context.Context, s NamedSecret) error
	// DeleteSecret deletes a secret by ID.
	DeleteSecret(ctx context.Context, id string) error
}