agent contains jujud's machine agent.



    This section is empty.


    View Source
    var ProductionMongoWriteConcern = true

      Variable to override in tests, default is true


      func MachineAgentFactoryFn

      func MachineAgentFactoryFn(
      	agentConfWriter AgentConfigWriter,
      	bufferedLogs logsender.LogRecordCh,
      	rootDir string,
      ) func(string) *MachineAgent

        MachineAgentFactoryFn returns a function which instantiates a MachineAgent given a machineId.

        func NewMachineAgentCmd

        func NewMachineAgentCmd(
        	ctx *cmd.Context,
        	machineAgentFactory func(string) *MachineAgent,
        	agentInitializer AgentInitializer,
        	configFetcher AgentConfigWriter,
        ) cmd.Command

          NewMachineAgentCmd creates a Command which handles parsing command-line arguments and instantiating and running a MachineAgent.

          func NewModelStorageDataSource

          func NewModelStorageDataSource(stor storage.Storage, priority int, requireSigned bool) simplestreams.DataSource

            NewModelStorageDataSource returns a new datasource that retrieves metadata from environment storage.


            type AgentConf

            type AgentConf interface {
            	// AddFlags injects common agent flags into f.
            	AddFlags(f *gnuflag.FlagSet)
            	// CheckArgs reports whether the given args are valid for this agent.
            	CheckArgs(args []string) error
            	// DataDir returns the directory where this agent should store its data.
            	DataDir() string
            	// ReadConfig reads the agent's config from its config file.
            	ReadConfig(tag string) error
            	// CurrentConfig returns the agent config for this agent.
            	CurrentConfig() agent.Config
            	// ChangeConfig modifies this configuration using the given mutator.
            	ChangeConfig(change agent.ConfigMutator) error

              AgentConf is a terribly confused interface.

              Parts of it are a mixin for cmd.Command implementations; others are a mixin for agent.Agent implementations; others bridge the two. We should be aiming to separate the cmd responsibilities from the agent responsibilities.

              func NewAgentConf

              func NewAgentConf(dataDir string) AgentConf

                NewAgentConf returns a new value that satisfies AgentConf

                type AgentConfigWriter

                type AgentConfigWriter interface {
                	// ReadConfig reads the config for the given tag from disk.
                	ReadConfig(tag string) error
                	// ChangeConfig executes the given agent.ConfigMutator in a
                	// thread-safe context.
                	ChangeConfig(agent.ConfigMutator) error
                	// CurrentConfig returns a copy of the in-memory agent config.
                	CurrentConfig() agent.Config

                  AgentConfigWriter encapsulates disk I/O operations with the agent config.

                  type AgentInitializer

                  type AgentInitializer interface {
                  	CheckArgs([]string) error

                    AgentInitializer handles initializing a type for use as a Jujud agent.

                    type MachineAgent

                    type MachineAgent struct {
                    	// contains filtered or unexported fields

                      MachineAgent is responsible for tying together all functionality needed to orchestrate a Jujud instance which controls a machine.

                      func NewMachineAgent

                      func NewMachineAgent(
                      	machineId string,
                      	agentConfWriter AgentConfigWriter,
                      	bufferedLogs logsender.LogRecordCh,
                      	runner worker.Runner,
                      	loopDeviceManager looputil.LoopDeviceManager,
                      	rootDir string,
                      ) *MachineAgent

                        NewMachineAgent instantiates a new MachineAgent.

                        func (*MachineAgent) BeginRestore

                        func (a *MachineAgent) BeginRestore() error

                          BeginRestore will flag the agent to disallow all commands since restore should be running and therefore making changes that would override anything done.

                          func (*MachineAgent) ChangeConfig

                          func (a *MachineAgent) ChangeConfig(mutate agent.ConfigMutator) error

                          func (*MachineAgent) EndRestore

                          func (a *MachineAgent) EndRestore()

                            EndRestore will flag the agent to allow all commands This being invoked means that restore process failed since success restarts the agent.

                            func (*MachineAgent) IsRestorePreparing

                            func (a *MachineAgent) IsRestorePreparing() bool

                              IsRestorePreparing returns bool representing if we are in restore mode but not running restore.

                              func (*MachineAgent) IsRestoreRunning

                              func (a *MachineAgent) IsRestoreRunning() bool

                                IsRestoreRunning returns bool representing if we are in restore mode and running the actual restore process.

                                func (*MachineAgent) PrepareRestore

                                func (a *MachineAgent) PrepareRestore() error

                                  PrepareRestore will flag the agent to allow only a limited set of commands defined in "".allowedMethodsAboutToRestore the most noteworthy is: Backups.Restore: this will ensure that we can do all the file movements required for restore and no one will do changes while we do that. it will return error if the machine is already in this state.

                                  func (*MachineAgent) Restart

                                  func (a *MachineAgent) Restart() error

                                    Restart restarts the agent's service.

                                    func (*MachineAgent) Run

                                    func (a *MachineAgent) Run(*cmd.Context) error

                                      Run runs a machine agent.

                                      func (*MachineAgent) Stop

                                      func (a *MachineAgent) Stop() error

                                        Stop stops the machine agent.

                                        func (*MachineAgent) Tag

                                        func (a *MachineAgent) Tag() names.Tag

                                        func (*MachineAgent) Wait

                                        func (a *MachineAgent) Wait() error

                                          Wait waits for the machine agent to finish.

                                          func (*MachineAgent) WorkersStarted

                                          func (a *MachineAgent) WorkersStarted() <-chan struct{}

                                            WorkersStarted returns a channel that's closed once all top level workers have been started. This is provided for testing purposes.

                                            type MongoSessioner

                                            type MongoSessioner interface {
                                            	MongoSession() *mgo.Session

                                            type UnitAgent

                                            type UnitAgent struct {
                                            	UnitName string
                                            	// contains filtered or unexported fields

                                              UnitAgent is a cmd.Command responsible for running a unit agent.

                                              func NewUnitAgent

                                              func NewUnitAgent(ctx *cmd.Context, bufferedLogs logsender.LogRecordCh) *UnitAgent

                                                NewUnitAgent creates a new UnitAgent value properly initialized.

                                                func (*UnitAgent) APIWorkers

                                                func (a *UnitAgent) APIWorkers() (worker.Worker, error)

                                                  APIWorkers returns a dependency.Engine running the unit agent's responsibilities.

                                                  func (*UnitAgent) ChangeConfig

                                                  func (a *UnitAgent) ChangeConfig(mutate agent.ConfigMutator) error

                                                  func (*UnitAgent) Info

                                                  func (a *UnitAgent) Info() *cmd.Info

                                                    Info returns usage information for the command.

                                                    func (*UnitAgent) Init

                                                    func (a *UnitAgent) Init(args []string) error

                                                      Init initializes the command for running.

                                                      func (*UnitAgent) Run

                                                      func (a *UnitAgent) Run(ctx *cmd.Context) error

                                                        Run runs a unit agent.

                                                        func (*UnitAgent) SetFlags

                                                        func (a *UnitAgent) SetFlags(f *gnuflag.FlagSet)

                                                        func (*UnitAgent) Stop

                                                        func (a *UnitAgent) Stop() error

                                                          Stop stops the unit agent.

                                                          func (*UnitAgent) Tag

                                                          func (a *UnitAgent) Tag() names.Tag


                                                          Path Synopsis