machinemanager

type Application interface {
	Name() string
	Charm() (Charm, bool, error)
	CharmOrigin() *state.CharmOrigin
}

type ApplicationValidator interface {
	// ValidateApplications attempts to validate a series of applications for
	// a given series. Using force to allow the overriding of the error to
	// ensure all applications validate.
	//
	// I do question if you actually need to validate anything if force is
	// employed here?
	ValidateApplications(applications []Application, base corebase.Base, force bool) error
}

type Authorizer interface {
	// CanRead checks to see if a read is possible. Returns an error if a read
	// is not possible.
	CanRead() error

	// CanWrite checks to see if a write is possible. Returns an error if a
	// write is not possible.
	CanWrite() error

	// AuthClient returns true if the entity is an external user.
	AuthClient() bool
}

type Backend interface {
	network.SpaceLookup

	// Application returns a application state by name.
	Application(string) (Application, error)
	Machine(string) (Machine, error)
	AllMachines() ([]Machine, error)
	Unit(string) (Unit, error)
	Model() (Model, error)
	GetBlockForType(t state.BlockType) (state.Block, bool, error)
	AddOneMachine(template state.MachineTemplate) (*state.Machine, error)
	AddMachineInsideNewMachine(template, parentTemplate state.MachineTemplate, containerType instance.ContainerType) (*state.Machine, error)
	AddMachineInsideMachine(template state.MachineTemplate, parentId string, containerType instance.ContainerType) (*state.Machine, error)
	ToolsStorage() (binarystorage.StorageCloser, error)
}

type BackendState interface {
	Backend
	MachineFromTag(string) (Machine, error)
}

type Charm interface {
	Meta() *charm.Meta
	Manifest() *charm.Manifest
}

type CharmhubClient interface {
	Refresh(ctx context.Context, config charmhub.RefreshConfig) ([]transport.RefreshResponse, error)
}

type ControllerBackend interface {
	ControllerTag() names.ControllerTag
	ControllerConfig() (controller.Config, error)
	APIHostPortsForAgents() ([]network.SpaceHostPorts, error)
}

type InstanceConfigBackend interface {
	Model() (Model, error)
	Machine(string) (Machine, error)
	ToolsStorage() (binarystorage.StorageCloser, error)
}

type Leadership interface {
	// GetMachineApplicationNames returns the applications associated with a
	// machine.
	GetMachineApplicationNames(string) ([]string, error)

	// UnpinApplicationLeadersByName takes a slice of application names and
	// attempts to unpin them accordingly.
	UnpinApplicationLeadersByName(names.Tag, []string) (params.PinApplicationsResults, error)
}

type Machine interface {
	Id() string
	Tag() names.Tag
	SetPassword(string) error
	HardwareCharacteristics() (*instance.HardwareCharacteristics, error)
	Destroy() error
	ForceDestroy(time.Duration) error
	Base() state.Base
	Containers() ([]string, error)
	Units() ([]Unit, error)
	SetKeepInstance(keepInstance bool) error
	CreateUpgradeSeriesLock([]string, state.Base) error
	RemoveUpgradeSeriesLock() error
	CompleteUpgradeSeries() error
	Principals() []string
	WatchUpgradeSeriesNotifications() (state.NotifyWatcher, error)
	GetUpgradeSeriesMessages() ([]string, bool, error)
	IsManager() bool
	IsLockedForSeriesUpgrade() (bool, error)
	UpgradeSeriesStatus() (model.UpgradeSeriesStatus, error)
	SetUpgradeSeriesStatus(model.UpgradeSeriesStatus, string) error
	ApplicationNames() ([]string, error)
	InstanceStatus() (status.StatusInfo, error)
	SetInstanceStatus(sInfo status.StatusInfo) error
}

type MachineManagerAPI struct {
	// contains filtered or unexported fields
}

type MachineManagerV9 struct {
	*MachineManagerAPI
}

type Model interface {
	Name() string
	UUID() string
	ModelTag() names.ModelTag
	ControllerUUID() string
	Type() state.ModelType
	Cloud() (cloud.Cloud, error)
	CloudCredential() (state.Credential, bool, error)
	CloudRegion() string
	Config() (*config.Config, error)
}

type ModelAuthorizer struct {
	ModelTag   names.ModelTag
	Authorizer facade.Authorizer
}

type Pool interface {
	GetModel(string) (Model, func(), error)
	SystemState() (ControllerBackend, error)
}

type StorageInterface interface {
	storagecommon.StorageAccess
	VolumeAccess() storagecommon.VolumeAccess
	FilesystemAccess() storagecommon.FilesystemAccess
}

type Unit interface {
	UnitTag() names.UnitTag
	Name() string
	AgentStatus() (status.StatusInfo, error)
	Status() (status.StatusInfo, error)
}

type UpgradeBaseValidator interface {
	ApplicationValidator

	// ValidateBase validates a given requested base against the current
	// machine base.
	// The machine tag is currently used for descriptive information and could
	// be deprecated in reality.
	ValidateBase(requestedBase, machineBase corebase.Base, machineTag string) error

	// ValidateMachine validates a given machine for ensuring it meets a given
	// state (quiescence essentially) and has no current ongoing machine lock.
	ValidateMachine(Machine) error

	// ValidateUnits validates a given set of units.
	ValidateUnits([]Unit) error
}

type UpgradeSeries interface {

	// Validate validates that the incoming arguments correspond to a
	// valid series upgrade for the target machine.
	// If they do, a list of the machine's current units is returned for use in
	// soliciting user confirmation of the command.
	Validate([]ValidationEntity) ([]ValidationResult, error)

	// Prepare attempts to prepare a machine for a OS series upgrade.
	// It is expected that a validate call has been performed before the prepare
	// step.
	Prepare(string, string, bool) error

	// Complete will complete the upgrade series.
	Complete(string) error
}

type UpgradeSeriesAPI struct {
	// contains filtered or unexported fields
}

type UpgradeSeriesState interface {
	// MachineFromTag returns a machine from a given tag.
	// Returns an error if the machine is not found.
	MachineFromTag(string) (Machine, error)

	// ApplicationsFromMachine returns a list of all the applications for a
	// given machine. This includes all the subordinates.
	ApplicationsFromMachine(Machine) ([]Application, error)
}

type ValidationEntity struct {
	Tag     string
	Channel string
	Force   bool
}

type ValidationResult struct {
	Error     error
	UnitNames []string
}