uniter

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

type ChannelCommandRunnerConfig struct {
	// Abort is a channel that will be closed when the runner should abort
	// the execution of run commands.
	Abort <-chan struct{}

	// Commands is used to add commands received from the listener.
	Commands runcommands.Commands

	// CommandChannel will be sent the IDs of commands added to Commands.
	CommandChannel chan<- string
}

type CommandRunner interface {
	RunCommands(RunCommandsArgs RunCommandsArgs) (results *exec.ExecResponse, err error)
}

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

type Logger interface {
	Errorf(string, ...interface{})
	Warningf(string, ...interface{})
	Infof(string, ...interface{})
	Debugf(string, ...interface{})
	Tracef(string, ...interface{})
	IsTraceEnabled() bool

	Child(string) loggo.Logger
	ChildWithLabels(name string, labels ...string) loggo.Logger
}

type ManifoldConfig struct {
	AgentName                    string
	ModelType                    model.ModelType
	APICallerName                string
	S3CallerName                 string
	MachineLock                  machinelock.Lock
	Clock                        clock.Clock
	LeadershipTrackerName        string
	CharmDirName                 string
	HookRetryStrategyName        string
	TranslateResolverErr         func(error) error
	Logger                       Logger
	Sidecar                      bool
	EnforcedCharmModifiedVersion int
	ContainerNames               []string
}

type NewOperationExecutorFunc func(string, operation.ExecutorConfig) (operation.Executor, error)

type NewPebbleClientFunc func(*client.Config) (PebbleClient, error)

type NewRunnerExecutorFunc func(ProviderIDGetter, Paths) runner.ExecFunc

type Paths struct {

	// ToolsDir is the directory containing the jujud executable running this
	// process; and also containing jujuc tool symlinks to that executable. It's
	// the only path in this struct that is not typically pointing inside the
	// directory reserved for the exclusive use of this worker (typically
	// /var/lib/juju/agents/$UNIT_TAG/ )
	ToolsDir string

	// Runtime represents the set of paths that are relevant at runtime.
	Runtime RuntimePaths

	// State represents the set of paths that hold persistent local state for
	// the uniter.
	State StatePaths
}

type PebbleClient interface {
	CloseIdleConnections()
	SysInfo() (*client.SysInfo, error)
	WaitNotices(ctx context.Context, serverTimeout time.Duration, opts *client.NoticesOptions) ([]*client.Notice, error)
}

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

type ProviderIDGetter interface {
	ProviderID() string
	Refresh() error
	Name() string
}

type RebootQuerier interface {
	Query(tag names.Tag) (bool, error)
}

type RemoteInitFunc func(remotestate.ContainerRunningStatus, <-chan struct{}) error

type ResolverConfig struct {
	ModelType           model.ModelType
	ClearResolved       func() error
	ReportHookError     func(hook.Info) error
	ShouldRetryHooks    bool
	StartRetryHookTimer func()
	StopRetryHookTimer  func()
	VerifyCharmProfile  resolver.Resolver
	UpgradeSeries       resolver.Resolver
	Reboot              resolver.Resolver
	Leadership          resolver.Resolver
	Actions             resolver.Resolver
	CreatedRelations    resolver.Resolver
	Relations           resolver.Resolver
	Storage             resolver.Resolver
	Commands            resolver.Resolver
	Secrets             resolver.Resolver
	OptionalResolvers   []resolver.Resolver
	Logger              Logger
}

type RunCommandsArgs struct {
	// Commands is the arbitrary commands to execute on the unit
	Commands string
	// RelationId is the relation context to execute the commands in.
	RelationId int
	// RemoteUnitName is the remote unit for the relation context.
	RemoteUnitName string
	// RemoteUnitName is the remote unit for the relation context.
	RemoteApplicationName string
	// ForceRemoteUnit skips relation membership and existence validation.
	ForceRemoteUnit bool
	// UnitName is the unit for which the command is being run.
	UnitName string
	// Token is the unit token when run under CAAS environments for auth.
	Token string
	// Operator is true when the command should be run on the operator.
	// This only affects k8s workload charms.
	Operator bool
}

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

type RuntimePaths struct {
	// LocalJujuExecSocket listens for juju-exec invocations, and is always
	// active.
	LocalJujuExecSocket SocketPair

	// RemoteJujuExecSocket listens for remote juju-exec invocations.
	RemoteJujuExecSocket SocketPair

	// JujucServerSocket listens for jujuc invocations, and is only
	// active when supporting a jujuc execution context.
	LocalJujucServerSocket SocketPair

	// RemoteJujucServerSocket listens for remote jujuc invocations, and is only
	// active when supporting a jujuc execution context.
	RemoteJujucServerSocket SocketPair
}

type SecretsClient interface {
	remotestate.SecretsClient
	context.SecretsAccessor
}

type SocketConfig struct {
	ServiceAddress  string
	OperatorAddress string
	TLSConfig       *tls.Config
}

type SocketPair struct {
	Server sockets.Socket
	Client sockets.Socket
}

type StatePaths struct {
	// BaseDir is the unit agent's base directory.
	BaseDir string

	// CharmDir is the directory to which the charm the uniter runs is deployed.
	CharmDir string

	// ResourcesDir is the directory to which the charm the uniter runs is deployed.
	ResourcesDir string

	// BundlesDir holds downloaded charms.
	BundlesDir string

	// DeployerDir holds metadata about charms that are installing or have
	// been installed.
	DeployerDir string

	// MetricsSpoolDir acts as temporary storage for metrics being sent from
	// the uniter to state.
	MetricsSpoolDir string
}

type Uniter struct {
	Probe Probe
	// contains filtered or unexported fields
}

type UniterExecutionObserver interface {
	HookCompleted(hookName string)
	HookFailed(hookName string)
}

type UniterParams struct {
	UniterFacade                  *uniter.State
	ResourcesFacade               *uniter.ResourcesFacadeClient
	PayloadFacade                 *uniter.PayloadFacadeClient
	SecretsClient                 SecretsClient
	SecretsBackendGetter          context.SecretsBackendGetter
	UnitTag                       names.UnitTag
	ModelType                     model.ModelType
	LeadershipTrackerFunc         func(names.UnitTag) leadership.TrackerWorker
	SecretRotateWatcherFunc       remotestate.SecretTriggerWatcherFunc
	SecretExpiryWatcherFunc       remotestate.SecretTriggerWatcherFunc
	DataDir                       string
	Downloader                    charm.Downloader
	MachineLock                   machinelock.Lock
	CharmDirGuard                 fortress.Guard
	UpdateStatusSignal            remotestate.UpdateStatusTimerFunc
	HookRetryStrategy             params.RetryStrategy
	NewOperationExecutor          NewOperationExecutorFunc
	NewProcessRunner              runner.NewRunnerFunc
	NewDeployer                   charm.NewDeployerFunc
	NewRemoteRunnerExecutor       NewRunnerExecutorFunc
	RemoteInitFunc                RemoteInitFunc
	RunListener                   *RunListener
	TranslateResolverErr          func(error) error
	Clock                         clock.Clock
	ContainerRunningStatusChannel watcher.NotifyChannel
	ContainerRunningStatusFunc    remotestate.ContainerRunningStatusFunc
	IsRemoteUnit                  bool
	SocketConfig                  *SocketConfig
	// TODO (mattyw, wallyworld, fwereade) Having the observer here make this approach a bit more legitimate, but it isn't.
	// the observer is only a stop gap to be used in tests. A better approach would be to have the uniter tests start hooks
	// that write to files, and have the tests watch the output to know that hooks have finished.
	Observer                     UniterExecutionObserver
	RebootQuerier                RebootQuerier
	Logger                       Logger
	Sidecar                      bool
	EnforcedCharmModifiedVersion int
	ContainerNames               []string
	NewPebbleClient              NewPebbleClientFunc
}