cache

type Application struct {
	// Resident identifies the application as a type-agnostic cached entity
	// and tracks resources that it is responsible for cleaning up.
	*Resident
	// contains filtered or unexported fields
}

type ApplicationChange struct {
	ModelUUID       string
	Name            string
	Exposed         bool
	CharmURL        string
	Life            life.Value
	MinUnits        int
	Constraints     constraints.Value
	Annotations     map[string]string
	Config          map[string]interface{}
	Subordinate     bool
	Status          status.StatusInfo
	OperatorStatus  status.StatusInfo // For CAAS applications.
	WorkloadVersion string
	PodSpec         *PodSpec // For CAAS applications.
}

type Branch struct {
	// Resident identifies the branch as a type-agnostic cached entity
	// and tracks resources that it is responsible for cleaning up.
	*Resident
	// contains filtered or unexported fields
}

type BranchChange struct {
	ModelUUID     string
	Id            string
	Name          string
	AssignedUnits map[string][]string
	Config        map[string]settings.ItemChanges
	Created       int64
	CreatedBy     string
	Completed     int64
	CompletedBy   string
	GenerationId  int
}

type Charm struct {
	// Resident identifies the charm as a type-agnostic cached entity
	// and tracks resources that it is responsible for cleaning up.
	*Resident
	// contains filtered or unexported fields
}

type CharmChange struct {
	ModelUUID     string
	CharmURL      string
	CharmVersion  string
	LXDProfile    lxdprofile.Profile
	DefaultConfig map[string]interface{}
}

type CharmConfigWatcher struct {
	CharmConfigHashCacheHitInc  func()
	CharmConfigHashCacheMissInc func()
	// contains filtered or unexported fields
}

type Clock interface {
	After(time.Duration) <-chan time.Time
}

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

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

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

type ControllerConfig struct {
	// Changes from the event source come over this channel.
	// The changes channel must be non-nil.
	Changes chan interface{}

	// Notify is a callback function used primarily for testing, and is
	// called by the controller main processing loop after processing a change.
	// The change processed is passed in as the arg to notify.
	Notify func(interface{})
}

type ControllerConfigChange struct {
	Config map[string]interface{}
}

type ControllerGauges struct {
	ModelConfigReads   prometheus.Gauge
	ModelHashCacheHit  prometheus.Gauge
	ModelHashCacheMiss prometheus.Gauge

	ApplicationConfigReads   prometheus.Gauge
	ApplicationHashCacheHit  prometheus.Gauge
	ApplicationHashCacheMiss prometheus.Gauge

	CharmConfigHashCacheHit  prometheus.Gauge
	CharmConfigHashCacheMiss prometheus.Gauge
}

type Endpoint struct {
	Application string
	Name        string
	Role        string
	Interface   string
	Optional    bool
	Limit       int
	Scope       string
}

type Machine struct {
	// Resident identifies the machine as a type-agnostic cached entity
	// and tracks resources that it is responsible for cleaning up.
	*Resident
	// contains filtered or unexported fields
}

type MachineChange struct {
	ModelUUID                string
	Id                       string
	InstanceId               string
	AgentStatus              status.StatusInfo
	InstanceStatus           status.StatusInfo
	Life                     life.Value
	Annotations              map[string]string
	Config                   map[string]interface{}
	Base                     string
	ContainerType            string
	IsManual                 bool
	SupportedContainers      []instance.ContainerType
	SupportedContainersKnown bool
	HardwareCharacteristics  *instance.HardwareCharacteristics
	CharmProfiles            []string
	Addresses                []network.ProviderAddress
	HasVote                  bool
	WantsVote                bool
}

type Model struct {
	// Resident identifies the model as a type-agnostic cached entity
	// and tracks resources that it is responsible for cleaning up.
	*Resident
	// contains filtered or unexported fields
}

type ModelChange struct {
	ModelUUID       string
	Name            string
	Type            model.ModelType
	Life            life.Value
	Owner           string // tag maybe?
	IsController    bool
	Cloud           string
	CloudRegion     string
	CloudCredential string
	Annotations     map[string]string
	Config          map[string]interface{}
	Status          status.StatusInfo

	UserPermissions map[string]permission.Access
}

type ModelSummary struct {
	UUID string
	// Removed indicates that the user can no longer see this model, because it has
	// either been removed, or there access revoked.
	Removed bool

	Controller  string
	Namespace   string
	Name        string
	Admins      []string
	Status      string
	Annotations map[string]string

	// Messages contain status message for any unit status in error.
	Messages []ModelSummaryMessage

	Cloud        string
	Region       string
	Credential   string
	LastModified time.Time // Currently missing in cache and underlying db model.

	// MachineCount is just top level machines.
	MachineCount     int
	ContainerCount   int
	ApplicationCount int
	UnitCount        int
	RelationCount    int
}

type ModelSummaryMessage struct {
	Agent   string
	Message string
}

type ModelSummaryWatcher interface {
	Watcher
	Changes() <-chan []ModelSummary
}

type ModelWatcher interface {
	Watcher
	Changes() <-chan *Model
}

type NotifyWatcher interface {
	Watcher
	Changes() <-chan struct{}
}

type PodSpec struct {
	Spec    string
	Raw     bool
	Counter int
}

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

type Relation struct {
	// Resident identifies the relation as a type-agnostic cached entity
	// and tracks resources that it is responsible for cleaning up.
	*Resident
	// contains filtered or unexported fields
}

type RelationChange struct {
	ModelUUID string
	Key       string
	Endpoints []Endpoint
}

type RemoveApplication struct {
	ModelUUID string
	Name      string
}

type RemoveBranch struct {
	ModelUUID string
	Id        string
}

type RemoveCharm struct {
	ModelUUID string
	CharmURL  string
}

type RemoveMachine struct {
	ModelUUID string
	Id        string
}

type RemoveModel struct {
	ModelUUID string
}

type RemoveRelation struct {
	ModelUUID string
	Key       string
}

type RemoveUnit struct {
	ModelUUID string
	Name      string
}

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

type StringsWatcher interface {
	Watcher
	Changes() <-chan []string
}

type Unit struct {
	// Resident identifies the unit as a type-agnostic cached entity
	// and tracks resources that it is responsible for cleaning up.
	*Resident
	// contains filtered or unexported fields
}

type UnitChange struct {
	ModelUUID                string
	Name                     string
	Application              string
	Base                     string
	Annotations              map[string]string
	CharmURL                 string
	Life                     life.Value
	PublicAddress            string
	PrivateAddress           string
	MachineId                string
	OpenPortRangesByEndpoint network.GroupedPortRanges
	Principal                string
	Subordinate              bool

	WorkloadStatus  status.StatusInfo
	AgentStatus     status.StatusInfo
	ContainerStatus status.StatusInfo // For CAAS models.
}

type Watcher interface {
	worker.Worker
	// Stop is currently needed by the apiserver until the resources
	// work on workers instead of things that can be stopped.
	Stop() error
}