platform

type ApplyError map[flux.ServiceID]error

type BusMetrics struct {
	KickCount metrics.Counter
}

type Connecter interface {
	// Connect returns a platform for the instance specified. An error
	// is returned only if there is a problem (possibly transient)
	// with the underlying mechanism (i.e., not if the platform is
	// simply not known to be connected at this time).
	Connect(inst flux.InstanceID) (Platform, error)
}

type Container struct {
	Name  string
	Image string
}

type ContainersOrExcuse struct {
	Excuse     string
	Containers []Container
}

type FatalError struct {
	Err error
}

type MessageBus interface {
	Connecter
	// Subscribe registers a platform as the daemon for the instance
	// specified.
	Subscribe(inst flux.InstanceID, p Platform, done chan<- error)
	// Ping returns nil if the daemon for the instance given is known
	// to be connected, or ErrPlatformNotAvailable otherwise. NB this
	// differs from the semantics of `Connecter.Connect`.
	Ping(inst flux.InstanceID) error
}

type MockPlatform struct {
	AllServicesArgTest func(string, flux.ServiceIDSet) error
	AllServicesAnswer  []Service
	AllServicesError   error

	SomeServicesArgTest func([]flux.ServiceID) error
	SomeServicesAnswer  []Service
	SomeServicesError   error

	ApplyArgTest func([]ServiceDefinition) error
	ApplyError   error

	PingError error

	VersionAnswer string
	VersionError  error

	ExportAnswer []byte
	ExportError  error

	SyncArgTest func(SyncDef) error
	SyncError   error
}

type Platform interface {
	PlatformV5
}

type PlatformV4 interface {
	AllServices(maybeNamespace string, ignored flux.ServiceIDSet) ([]Service, error)
	SomeServices([]flux.ServiceID) ([]Service, error)
	Apply([]ServiceDefinition) error
	Ping() error
	Version() (string, error)
}

type PlatformV5 interface {
	PlatformV4
	// Additional methods accumulate here as we develop V5
	Export() ([]byte, error)
	Sync(SyncDef) error
}

type ResourceDef []byte

type Service struct {
	ID       flux.ServiceID
	IP       string
	Metadata map[string]string // a grab bag of goodies, likely platform-specific
	Status   string            // A status summary for display

	Containers ContainersOrExcuse
}

type ServiceDefinition struct {
	ServiceID     flux.ServiceID
	NewDefinition []byte // of the pod controller e.g. deployment
	Async         bool   // Should this definition be applied without waiting for the result.
}

type StandaloneMessageBus struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type SyncAction struct {
	// The ID is just a handle for labeling any error. No other
	// meaning is attached to it.
	ResourceID string
	Delete     ResourceDef
	Apply      ResourceDef
}

type SyncDef struct {
	// The actions to undertake
	Actions []SyncAction
}

type SyncError map[string]error