application

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

type APIv13 struct {
	*APIBase
}

type AgentTools interface {
	AgentTools() (*tools.Tools, error)
}

type AgentVersioner interface {
	AgentVersion() (version.Number, error)
}

type Application interface {
	Name() string
	AddUnit(state.AddUnitParams) (Unit, error)
	AllUnits() ([]Unit, error)
	ApplicationConfig() (application.ConfigAttributes, error)
	Charm() (Charm, bool, error)
	CharmURL() (*charm.URL, bool)
	Channel() csparams.Channel
	CharmOrigin() *state.CharmOrigin
	ClearExposed() error
	CharmConfig(string) (charm.Settings, error)
	Constraints() (constraints.Value, error)
	Destroy() error
	DestroyOperation() *state.DestroyApplicationOperation
	EndpointBindings() (Bindings, error)
	ExposedEndpoints() map[string]state.ExposedEndpoint
	Endpoints() ([]state.Endpoint, error)
	IsExposed() bool
	IsPrincipal() bool
	IsRemote() bool
	Series() string
	SetCharm(state.SetCharmConfig) error
	SetConstraints(constraints.Value) error
	MergeExposeSettings(map[string]state.ExposedEndpoint) error
	UnsetExposeSettings([]string) error
	SetMetricCredentials([]byte) error
	SetMinUnits(int) error
	UpdateApplicationSeries(string, bool) error
	UpdateCharmConfig(string, charm.Settings) error
	UpdateApplicationConfig(application.ConfigAttributes, []string, environschema.Fields, schema.Defaults) error
	SetScale(int, int64, bool) error
	ChangeScale(int) (int, error)
	AgentTools() (*tools.Tools, error)
	MergeBindings(*state.Bindings, bool) error
	Relations() ([]Relation, error)
}

type ApplicationDeployer interface {
	AddApplication(state.AddApplicationArgs) (Application, error)
}

type Backend interface {
	AllModelUUIDs() ([]string, error)
	Application(string) (Application, error)
	ApplyOperation(state.ModelOperation) error
	AddApplication(state.AddApplicationArgs) (Application, error)
	RemoteApplication(string) (RemoteApplication, error)
	AddRemoteApplication(state.AddRemoteApplicationParams) (RemoteApplication, error)
	AddRelation(...state.Endpoint) (Relation, error)
	Charm(*charm.URL) (Charm, error)
	EndpointsRelation(...state.Endpoint) (Relation, error)
	Relation(int) (Relation, error)
	InferEndpoints(...string) ([]state.Endpoint, error)
	Machine(string) (Machine, error)
	Unit(string) (Unit, error)
	UnitsInError() ([]Unit, error)
	SaveController(info crossmodel.ControllerInfo, modelUUID string) (ExternalController, error)
	ControllerTag() names.ControllerTag
	ControllerConfig() (controller.Config, error)
	Resources() (Resources, error)
	OfferConnectionForRelation(string) (OfferConnection, error)
	SaveEgressNetworks(relationKey string, cidrs []string) (state.RelationNetworks, error)
	Branch(string) (Generation, error)
	state.EndpointBinding
}

type Bindings interface {
	Map() map[string]string
	MapWithSpaceNames(network.SpaceInfos) (map[string]string, error)
}

type BlockChecker interface {
	ChangeAllowed() error
	RemoveAllowed() error
}

type Charm interface {
	charm.Charm
	URL() *charm.URL
	String() string
}

type CharmArchive struct {
	// ID is the charm URL for which we're storing the archive.
	ID *charm.URL

	// Charm is the metadata about the charm for the archive.
	Charm charm.Charm

	// Data contains the bytes of the archive.
	Data io.Reader

	// Size is the number of bytes in Data.
	Size int64

	// SHA256 is the hash of the bytes in Data.
	SHA256 string

	// Macaroon is the authorization macaroon for accessing the charmstore.
	Macaroon macaroon.Slice

	// Charm Version contains semantic version of charm, typically the output of git describe.
	CharmVersion string
}

type CharmMeta interface {
	ComputedSeries() []string
}

type CharmState interface {
	UpdateUploadedCharm(info state.CharmInfo) (*state.Charm, error)
	PrepareCharmUpload(curl *charm.URL) (StateCharm, error)
}

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

type ControllerState interface {
	ControllerConfig() (controller.Config, error)
}

type DeployApplicationParams struct {
	ApplicationName   string
	Series            string
	Charm             *state.Charm
	CharmOrigin       corecharm.Origin
	Channel           csparams.Channel
	ApplicationConfig *application.Config
	CharmConfig       charm.Settings
	Constraints       constraints.Value
	NumUnits          int
	// Placement is a list of placement directives which may be used
	// instead of a machine spec.
	Placement        []*instance.Placement
	Storage          map[string]storage.Constraints
	Devices          map[string]devices.Constraints
	AttachStorage    []names.StorageTag
	EndpointBindings map[string]string
	// Resources is a map of resource name to IDs of pending resources.
	Resources map[string]string
}

type ExternalController state.ExternalController

type Generation interface {
	AssignApplication(string) error
}

type Machine interface {
	PublicAddress() (network.SpaceAddress, error)
	IsLockedForSeriesUpgrade() (bool, error)
	IsParentLockedForSeriesUpgrade() (bool, error)
}

type Model interface {
	ModelTag() names.ModelTag
	Name() string
	Owner() names.UserTag
	Tag() names.Tag
	Type() state.ModelType
	ModelConfig() (*config.Config, error)
	AgentVersion() (version.Number, error)
	OpenedPortRangesForMachine(string) (state.MachinePortRanges, error)
}

type ModelState interface {
	Model() (StateModel, error)
	ModelUUID() string
}

type OfferConnection interface{}

type OpenCSRepoFunc func(args OpenCSRepoParams) (Repository, error)

type OpenCSRepoParams struct {
	CSURL              string
	Channel            string
	CharmStoreMacaroon *macaroon.Macaroon
}

type Relation interface {
	status.StatusSetter
	Tag() names.Tag
	Destroy() error
	DestroyWithForce(bool, time.Duration) ([]error, error)
	Endpoints() []state.Endpoint
	RelatedEndpoints(applicationname string) ([]state.Endpoint, error)
	ApplicationSettings(appName string) (map[string]interface{}, error)
	AllRemoteUnits(appName string) ([]RelationUnit, error)
	Unit(string) (RelationUnit, error)
	Endpoint(string) (state.Endpoint, error)
	SetSuspended(bool, string) error
	Suspended() bool
	SuspendedReason() string
}

type RelationUnit interface {
	UnitName() string
	InScope() (bool, error)
	Settings() (map[string]interface{}, error)
}

type RemoteApplication interface {
	Name() string
	SourceModel() names.ModelTag
	Endpoints() ([]state.Endpoint, error)
	AddEndpoints(eps []charm.Relation) error
	Bindings() map[string]string
	Spaces() []state.RemoteSpace
	Destroy() error
	DestroyOperation(force bool) *state.DestroyRemoteApplicationOperation
}

type Repository interface {
	// FindDownloadURL returns a url from which a charm can be downloaded
	// based on the given charm url and charm origin.  A charm origin
	// updated with the ID and hash for the download is also returned.
	FindDownloadURL(curl *charm.URL, origin corecharm.Origin) (*url.URL, corecharm.Origin, error)

	// DownloadCharm reads the charm referenced by curl or downloadURL into
	// a file with the given path, which will be created if needed. Note
	// that the path's parent directory must already exist.
	DownloadCharm(resourceURL string, archivePath string) (*charm.CharmArchive, error)

	// Resolve a canonical URL for retrieving the charm includes the most
	// current revision, if none was provided and a slice  of series supported
	// by this charm.
	Resolve(ref *charm.URL) (canonRef *charm.URL, supportedSeries []string, err error)
}

type Resources interface {
	RemovePendingAppResources(string, map[string]string) error
}

type State interface {
	CharmState
	ModelState
	ControllerState
	state.MongoSessioner
}

type StateCharm interface {
	IsUploaded() bool
}

type StateModel interface {
	ModelConfig() (*config.Config, error)
}

type Subnet interface {
	CIDR() string
	VLANTag() int
	ProviderId() network.Id
	ProviderNetworkId() network.Id
}

type Unit interface {
	Name() string
	Tag() names.Tag
	UnitTag() names.UnitTag
	ApplicationName() string
	Destroy() error
	DestroyOperation() *state.DestroyUnitOperation
	IsPrincipal() bool
	Life() state.Life
	Resolve(retryHooks bool) error
	AgentTools() (*tools.Tools, error)

	AssignedMachineId() (string, error)
	WorkloadVersion() (string, error)
	AssignWithPolicy(state.AssignmentPolicy) error
	AssignWithPlacement(*instance.Placement) error
	ContainerInfo() (state.CloudContainer, error)
}

type UnitAdder interface {
	AddUnit(state.AddUnitParams) (Unit, error)
}

type UpdateSeries interface {

	// UpdateSeries attempts to update an application series for deploying new
	// units.
	UpdateSeries(string, string, bool) error
}

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

type UpdateSeriesState interface {
	// Application returns a list of all the applications for a
	// given machine. This includes all the subordinates.
	Application(string) (Application, error)
}

type UpdateSeriesValidator interface {
	// ValidateApplication attempts to validate an application for
	// a given series. Using force to allow the overriding of the error to
	// ensure all application validate.
	//
	// I do question if you actually need to validate anything if force is
	// employed here?
	ValidateApplication(application Application, series string, force bool) error
}