ds

type DSFarmConfig struct {
	// PodBlacklist represents pod IDs that the farm should skip over. In other
	// words, if the daemon set's pod ID matches one of these the farm will
	// refuse to service it
	PodBlacklist []types.PodID `yaml:"pod_blacklist" json:"pod_blacklist"`

	// PodWhitelist contains the set of pod IDs that the farm should exclusively
	// service. If there is at least one entry in here, all daemon sets with pod
	// IDs other than the ones included in the whitelist will be ignored by this
	// farm
	PodWhitelist []types.PodID `yaml:"pod_whitelist" json:"pod_whitelist"`

	StatusWritingInterval time.Duration
}

type DaemonSet interface {
	ID() fields.ID

	IsDisabled() bool

	// Returns the daemon set's pod id
	PodID() types.PodID

	ClusterName() fields.ClusterName

	GetNodeSelector() klabels.Selector

	// Returns a list of all nodes that are selected by this daemon set's selector
	EligibleNodes() ([]types.NodeName, error)

	MetricNames(suffix string) []string

	// WatchDesires watches for changes to its daemon set, then schedule/unschedule
	// pods to to the nodes that it is responsible for
	//
	// Whatever calls WatchDesires is responsible for sending signals for whether
	// the daemon set updated or deleted
	//
	// When this is first called, it assumes that the daemon set is created
	//
	// The caller is responsible for sending signals when something has been changed
	WatchDesires(
		ctx context.Context,
		updatedCh <-chan fields.DaemonSet,
		deletedCh <-chan fields.DaemonSet,
	) <-chan error

	// CurrentPods() returns all nodes that are scheduled by this daemon set
	CurrentPods() (types.PodLocations, error)

	Replicate(context.Context, <-chan []types.NodeName, <-chan struct{}, <-chan struct{}, <-chan manifest.Manifest, <-chan time.Duration)
}

type DaemonSetLocker interface {
	LockForOwnershipTxn(
		lockCtx context.Context,
		dsID fields.ID,
		session consul.Session,
	) (consul.TxnUnlocker, error)
}

type DaemonSetStore interface {
	List() ([]fields.DaemonSet, error)
	Watch(quitCh <-chan struct{}) <-chan dsstore.WatchedDaemonSets
	Disable(id fields.ID) (fields.DaemonSet, error)
}

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

type LabelWatcher interface {
	WatchMatchDiff(
		selector klabels.Selector,
		labelType labels.Type,
		aggregationRate time.Duration,
		quitCh <-chan struct{},
	) <-chan *labels.LabeledChanges
}

type Labeler interface {
	SetLabelsTxn(ctx context.Context, labelType labels.Type, id string, labels map[string]string) error
	RemoveLabelTxn(
		ctx context.Context,
		labelType labels.Type,
		id string,
		name string,
	) error
	GetMatches(selector klabels.Selector, labelType labels.Type) ([]labels.Labeled, error)
	GetCachedMatches(selector klabels.Selector, labelType labels.Type, aggregationRate time.Duration) ([]labels.Labeled, error)
	GetLabels(labelType labels.Type, id string) (labels.Labeled, error)
}

type Scheduler interface {
	EligibleNodes(manifest.Manifest, klabels.Selector) ([]types.NodeName, error)
}

type StatusStore interface {
	Get(dsID fields.ID) (daemonsetstatus.Status, *api.QueryMeta, error)
	SetTxn(ctx context.Context, dsID fields.ID, status daemonsetstatus.Status) error
}