twelvefactor

type CRONSchedule string

type Exposure struct {
	// External means that this process will be exposed to internet facing
	// traffic, as opposed to being internal. How this is used is
	// implementation specific. For ECS, this means that the attached ELB
	// will be "internet-facing".
	External bool

	// The ports to expose and map to the container.
	Ports []Port
}

type HTTP struct{}

type HTTPS struct {
	// The certificate to attach to the process.
	Cert string
}

type Host struct {
	// The host ID.
	ID string
}

type Manifest struct {
	// The id of the app.
	AppID string

	// An identifier that represents the version of this release.
	Release string

	// The name of the app.
	Name string

	// The application environment.
	Env map[string]string

	// The application labels.
	Labels map[string]string

	// Process that belong to this app.
	Processes []*Process
}

type Port struct {
	// The port that external applications will connect to. It's
	// implementation specific as to what this is used for. For example,
	// with ECS, this is used as the LoadBalancerPort.
	Host int

	// The port within the container that the process should bind to.
	Container int

	// The exposure type (e.g. HTTPExposure, HTTPSExposure, TCPExposure).
	Protocol Protocol
}

type Process struct {
	// The type of process.
	Type string

	// The Image to run.
	Image image.Image

	// The Command to run.
	Command []string

	// Environment variables to set.
	Env map[string]string

	// Labels to set on the container.
	Labels map[string]string

	// The amount of RAM to allocate to this process in bytes.
	Memory uint

	// The amount of CPU to allocate to this process, out of 1024. Maps to
	// the --cpu-shares flag for docker.
	CPUShares uint

	// ulimit -u
	Nproc uint

	// Quantity is the desired instances of this service to run.
	Quantity int

	// Exposure is the level of exposure for this process.
	Exposure *Exposure

	// Can be used to setup a CRON schedule to run this task periodically.
	Schedule Schedule

	// Any ECS specific configuration.
	ECS *procfile.ECS

	// Input/Output streams.
	Stdin          io.Reader
	Stdout, Stderr io.Writer
}

type Protocol interface {
	Protocol() string
}

type SSL struct {
	// The certificate to attach to the process.
	Cert string
}

type Schedule interface{}

type Scheduler interface {
	// Run runs a process.
	Run(ctx context.Context, app *Manifest) error

	// Submit submits an app, creating it or updating it as necessary.
	// When StatusStream is nil, Submit should return as quickly as possible,
	// usually when the new version has been received, and validated. If
	// StatusStream is not nil, it's recommended that the method not return until
	// the deployment has fully completed.
	Submit(context.Context, *Manifest, StatusStream) error

	// Remove removes the App.
	Remove(ctx context.Context, app string) error

	// Instance lists the instances of a Process for an app.
	Tasks(ctx context.Context, app string) ([]*Task, error)

	// Stop stops an instance. The scheduler will automatically start a new
	// instance.
	Stop(ctx context.Context, instanceID string) error

	// Restart restarts the processes within the App.
	Restart(context.Context, string, StatusStream) error
}

type Status struct {
	// A friendly human readable message about the status change.
	Message string
}

type StatusStream interface {
	// Publish publishes an update to the status stream
	Publish(Status) error
}

type StatusStreamFunc func(Status) error

type TCP struct{}

type Task struct {
	Process *Process

	// The instance ID.
	ID string

	// The instance host
	Host Host

	// The State that this Instance is in.
	State string

	// The time that this instance was last updated.
	UpdatedAt time.Time
}