juju: github.com/juju/juju/cmd/jujud/agent/machine Index | Files

package machine

import "github.com/juju/juju/cmd/jujud/agent/machine"

Index

Package Files

apiworkers.go manifolds.go stateflag.go

func APIWorkersManifold Uses

func APIWorkersManifold(config APIWorkersConfig) dependency.Manifold

APIWorkersManifold starts workers that rely on an API connection using a function provided to it.

This manifold exists to start API workers which have not yet been ported to work directly with the dependency engine. Once all API workers started by StartAPIWorkers have been migrated to the dependency engine, this manifold can be removed.

func CAASManifolds Uses

func CAASManifolds(config ManifoldsConfig) dependency.Manifolds

CAASManifolds returns a set of co-configured manifolds covering the various responsibilities of a CAAS machine agent.

func IAASManifolds Uses

func IAASManifolds(config ManifoldsConfig) dependency.Manifolds

IAASManifolds returns a set of co-configured manifolds covering the various responsibilities of a IAAS machine agent.

type APIWorkersConfig Uses

type APIWorkersConfig struct {
    APICallerName   string
    StartAPIWorkers func(api.Connection) (worker.Worker, error)
}

APIWorkersConfig provides the dependencies for the apiworkers manifold.

type ManifoldsConfig Uses

type ManifoldsConfig struct {

    // AgentName is the name of the machine agent, like "machine-12".
    // This will never change during the execution of an agent, and
    // is used to provide this as config into a worker rather than
    // making the worker get it from the agent worker itself.
    AgentName string

    // Agent contains the agent that will be wrapped and made available to
    // its dependencies via a dependency.Engine.
    Agent coreagent.Agent

    // AgentConfigChanged is set whenever the machine agent's config
    // is updated.
    AgentConfigChanged *voyeur.Value

    // RootDir is the root directory that any worker that needs to
    // access local filesystems should use as a base. In actual use it
    // will be "" but it may be overridden in tests.
    RootDir string

    // PreviousAgentVersion passes through the version the machine
    // agent was running before the current restart.
    PreviousAgentVersion version.Number

    // UpgradeStepsLock is passed to the upgrade steps gate to
    // coordinate workers that shouldn't do anything until the
    // upgrade-steps worker is done.
    UpgradeStepsLock gate.Lock

    // UpgradeCheckLock is passed to the upgrade check gate to
    // coordinate workers that shouldn't do anything until the
    // upgrader worker completes it's first check.
    UpgradeCheckLock gate.Lock

    // OpenController is function used by the controller manifold to
    // create a *state.Controller.
    OpenController func(coreagent.Config) (*state.Controller, error)

    // OpenStatePool is function used by the state manifold to create a
    // *state.StatePool.
    OpenStatePool func(coreagent.Config) (*state.StatePool, error)

    // OpenStateForUpgrade is a function the upgradesteps worker can
    // use to establish a connection to state.
    OpenStateForUpgrade func() (*state.StatePool, error)

    // StartAPIWorkers is passed to the apiworkers manifold. It starts
    // workers which rely on an API connection (which have not yet
    // been converted to work directly with the dependency engine).
    StartAPIWorkers func(api.Connection) (worker.Worker, error)

    // PreUpgradeSteps is a function that is used by the upgradesteps
    // worker to ensure that conditions are OK for an upgrade to
    // proceed.
    PreUpgradeSteps func(*state.StatePool, coreagent.Config, bool, bool, bool) error

    // LogSource defines the channel type used to send log message
    // structs within the machine agent.
    LogSource logsender.LogRecordCh

    // newDeployContext gives the tests the opportunity to create a deployer.Context
    // that can be used for testing so as to avoid (1) deploying units to the system
    // running the tests and (2) get access to the *State used internally, so that
    // tests can be run without waiting for the 5s watcher refresh time to which we would
    // otherwise be restricted.
    NewDeployContext func(st *apideployer.State, agentConfig coreagent.Config) deployer.Context

    // Clock supplies timekeeping services to various workers.
    Clock clock.Clock

    // ValidateMigration is called by the migrationminion during the
    // migration process to check that the agent will be ok when
    // connected to the new target controller.
    ValidateMigration func(base.APICaller) error

    // PrometheusRegisterer is a prometheus.Registerer that may be used
    // by workers to register Prometheus metric collectors.
    PrometheusRegisterer prometheus.Registerer

    // CentralHub is the primary hub that exists in the apiserver.
    CentralHub *pubsub.StructuredHub

    // PubSubReporter is the introspection reporter for the pubsub forwarding
    // worker.
    PubSubReporter psworker.Reporter

    // PresenceRecorder
    PresenceRecorder presence.Recorder

    // UpdateLoggerConfig is a function that will save the specified
    // config value as the logging config in the agent.conf file.
    UpdateLoggerConfig func(string) error

    // UpdateControllerAPIPort is a function that will save the updated
    // controller api port in the agent.conf file.
    UpdateControllerAPIPort func(int) error

    // NewAgentStatusSetter provides upgradesteps.StatusSetter.
    NewAgentStatusSetter func(apiConn api.Connection) (upgradesteps.StatusSetter, error)

    // ControllerLeaseDuration defines for how long this agent will ask
    // for controller administration rights.
    ControllerLeaseDuration time.Duration

    // LogPruneInterval defines how frequently logs are pruned from
    // the database.
    LogPruneInterval time.Duration

    // TransactionPruneInterval defines how frequently mgo/txn transactions
    // are pruned from the database.
    TransactionPruneInterval time.Duration

    // SetStatePool is used by the state worker for informing the agent of
    // the StatePool that it creates, so we can pass it to the introspection
    // worker running outside of the dependency engine.
    SetStatePool func(*state.StatePool)

    // RegisterIntrospectionHTTPHandlers is a function that calls the
    // supplied function to register introspection HTTP handlers. The
    // function will be passed a path and a handler; the function may
    // alter the path as it sees fit, e.g. by adding a prefix.
    RegisterIntrospectionHTTPHandlers func(func(path string, _ http.Handler))

    // NewModelWorker returns a new worker for managing the model with
    // the specified UUID and type.
    NewModelWorker modelworkermanager.NewModelWorkerFunc

    // MachineLock is a central source for acquiring the machine lock.
    // This is used by a number of workers to ensure serialisation of actions
    // across the machine.
    MachineLock machinelock.Lock

    // MuxShutdownWait is the maximum time the http-server worker will wait
    // for all mux clients to gracefully terminate before the http-worker
    // exits regardless.
    MuxShutdownWait time.Duration

    // NewContainerBrokerFunc is a function opens a CAAS provider.
    NewContainerBrokerFunc caas.NewContainerBrokerFunc

    // NewBrokerFunc is a function opens a instance broker (LXD/KVM)
    NewBrokerFunc containerbroker.NewBrokerFunc
}

ManifoldsConfig allows specialisation of the result of Manifolds.

Package machine imports 90 packages (graph) and is imported by 23 packages. Updated 2019-10-14. Refresh now. Tools for package owners.