// start is a StartFunc for a Worker manifold.
func (config ManifoldConfig) start(context dependency.Context) (worker.Worker, error) {
if err := config.validate(); err != nil {
return nil, errors.Trace(err)
}
var apiCaller base.APICaller
if err := context.Get(config.APICallerName, &apiCaller); err != nil {
return nil, errors.Trace(err)
}
facade, err := config.NewFacade(apiCaller)
if err != nil {
return nil, errors.Trace(err)
}
modelTag, err := apiCaller.ModelTag()
if err != nil {
return nil, errors.Trace(err)
}
worker, err := config.NewWorker(Config{
Facade: facade,
Model: modelTag.Id(),
Check: config.Check,
})
if err != nil {
return nil, errors.Trace(err)
}
return worker, nil
}
// start is a StartFunc for a Worker manifold.
func (config ManifoldConfig) start(context dependency.Context) (worker.Worker, error) {
if err := config.validate(); err != nil {
return nil, errors.Trace(err)
}
var apiCaller base.APICaller
if err := context.Get(config.APICallerName, &apiCaller); err != nil {
return nil, errors.Trace(err)
}
var guard fortress.Guard
if err := context.Get(config.FortressName, &guard); err != nil {
return nil, errors.Trace(err)
}
facade, err := config.NewFacade(apiCaller)
if err != nil {
return nil, errors.Trace(err)
}
worker, err := config.NewWorker(Config{
Facade: facade,
Guard: guard,
})
if err != nil {
return nil, errors.Trace(err)
}
return worker, nil
}
// start is a dependency.StartFunc that uses config.
func (config FlagManifoldConfig) start(context dependency.Context) (worker.Worker, error) {
var gate Waiter
if err := context.Get(config.GateName, &gate); err != nil {
return nil, errors.Trace(err)
}
worker, err := config.NewWorker(gate)
if err != nil {
return nil, errors.Trace(err)
}
return worker, nil
}
func (mh *tracedManifoldHarness) start(context dependency.Context) (worker.Worker, error) {
for _, resourceName := range mh.inputs {
if err := context.Get(resourceName, nil); err != nil {
return nil, errors.Trace(err)
}
}
w := &minimalWorker{tomb.Tomb{}, mh.ignoreExternalKill}
go func() {
defer w.tomb.Done()
mh.starts <- struct{}{}
select {
case <-w.tombDying():
case err := <-mh.errors:
w.tomb.Kill(err)
}
}()
return w, nil
}
func newStatusWorker(config ManifoldConfig, context dependency.Context) (worker.Worker, error) {
var agent agent.Agent
if err := context.Get(config.AgentName, &agent); err != nil {
return nil, err
}
tag := agent.CurrentConfig().Tag()
unitTag, ok := tag.(names.UnitTag)
if !ok {
return nil, errors.Errorf("expected unit tag, got %v", tag)
}
agentConfig := agent.CurrentConfig()
stateFile := NewStateFile(path.Join(agentConfig.DataDir(), "meter-status.yaml"))
runner := config.NewHookRunner(unitTag, config.MachineLockName, agentConfig, config.Clock)
// If we don't have a valid APICaller, start a meter status
// worker that works without an API connection.
var apiCaller base.APICaller
err := context.Get(config.APICallerName, &apiCaller)
if errors.Cause(err) == dependency.ErrMissing {
logger.Tracef("API caller dependency not available, starting isolated meter status worker.")
cfg := IsolatedConfig{
Runner: runner,
StateFile: stateFile,
Clock: config.Clock,
AmberGracePeriod: defaultAmberGracePeriod,
RedGracePeriod: defaultRedGracePeriod,
TriggerFactory: GetTriggers,
}
return config.NewIsolatedStatusWorker(cfg)
} else if err != nil {
return nil, err
}
logger.Tracef("Starting connected meter status worker.")
status := config.NewMeterStatusAPIClient(apiCaller, unitTag)
cfg := ConnectedConfig{
Runner: runner,
StateFile: stateFile,
Status: status,
}
return config.NewConnectedStatusWorker(cfg)
}
func (config ManifoldConfig) start(context dependency.Context) (worker.Worker, error) {
var environ environs.Environ
if err := context.Get(config.EnvironName, &environ); err != nil {
return nil, errors.Trace(err)
}
var apiCaller base.APICaller
if err := context.Get(config.APICallerName, &apiCaller); err != nil {
return nil, errors.Trace(err)
}
facade := instancepoller.NewAPI(apiCaller)
w, err := NewWorker(Config{
Facade: facade,
Environ: environ,
})
if err != nil {
return nil, errors.Trace(err)
}
return w, nil
}
func (config ManifoldConfig) start(context dependency.Context) (worker.Worker, error) {
var apiCaller base.APICaller
if err := context.Get(config.APICallerName, &apiCaller); err != nil {
return nil, errors.Trace(err)
}
facade, err := config.NewFacade(apiCaller)
if err != nil {
return nil, errors.Trace(err)
}
worker, err := config.NewWorker(Config{
Facade: facade,
Entity: config.Entity,
Result: config.Result,
})
if err != nil {
return nil, errors.Trace(err)
}
return worker, nil
}
// start is a method on ManifoldConfig because it's more readable than a closure.
func (config ManifoldConfig) start(context dependency.Context) (worker.Worker, error) {
var clock clock.Clock
if err := context.Get(config.ClockName, &clock); err != nil {
return nil, errors.Trace(err)
}
var apiCaller base.APICaller
if err := context.Get(config.APICallerName, &apiCaller); err != nil {
return nil, errors.Trace(err)
}
var agent agent.Agent
if err := context.Get(config.AgentName, &agent); err != nil {
return nil, errors.Trace(err)
}
agentTag := agent.CurrentConfig().Tag()
machineTag, ok := agentTag.(names.MachineTag)
if !ok {
return nil, errors.New("singular flag expected a machine agent")
}
// TODO(fwereade): model id is implicit in apiCaller, would
// be better if explicit.
facade, err := config.NewFacade(apiCaller, machineTag)
if err != nil {
return nil, errors.Trace(err)
}
flag, err := config.NewWorker(FlagConfig{
Clock: clock,
Facade: facade,
Duration: config.Duration,
})
if err != nil {
return nil, errors.Trace(err)
}
return flag, nil
}
// start is a StartFunc for a Worker manifold.
func (config ManifoldConfig) start(context dependency.Context) (worker.Worker, error) {
if runtime.GOOS == "windows" {
logger.Debugf("no SSH host keys to report on Windows machines")
return nil, dependency.ErrUninstall
}
if err := config.validate(); err != nil {
return nil, errors.Trace(err)
}
var agent agent.Agent
if err := context.Get(config.AgentName, &agent); err != nil {
return nil, errors.Trace(err)
}
var apiCaller base.APICaller
if err := context.Get(config.APICallerName, &apiCaller); err != nil {
return nil, errors.Trace(err)
}
tag := agent.CurrentConfig().Tag()
if _, ok := tag.(names.MachineTag); !ok {
return nil, errors.New("hostkeyreporter may only be used with a machine agent")
}
facade, err := config.NewFacade(apiCaller)
if err != nil {
return nil, errors.Trace(err)
}
worker, err := config.NewWorker(Config{
Facade: facade,
MachineId: tag.Id(),
RootDir: config.RootDir,
})
if err != nil {
return nil, errors.Trace(err)
}
return worker, nil
}
// start is a StartFunc for a Worker manifold.
func (config ManifoldConfig) start(context dependency.Context) (worker.Worker, error) {
if err := config.Validate(); err != nil {
return nil, errors.Trace(err)
}
var agent agent.Agent
if err := context.Get(config.AgentName, &agent); err != nil {
return nil, errors.Trace(err)
}
var apiConn api.Connection
if err := context.Get(config.APICallerName, &apiConn); err != nil {
return nil, errors.Trace(err)
}
var guard fortress.Guard
if err := context.Get(config.FortressName, &guard); err != nil {
return nil, errors.Trace(err)
}
facade, err := config.NewFacade(apiConn)
if err != nil {
return nil, errors.Trace(err)
}
apiClient := apiConn.Client()
worker, err := config.NewWorker(Config{
ModelUUID: agent.CurrentConfig().Model().Id(),
Facade: facade,
Guard: guard,
APIOpen: api.Open,
UploadBinaries: migration.UploadBinaries,
CharmDownloader: apiClient,
ToolsDownloader: apiClient,
Clock: config.Clock,
})
if err != nil {
return nil, errors.Trace(err)
}
return worker, nil
}
func newCollect(config ManifoldConfig, context dependency.Context) (*collect, error) {
period := defaultPeriod
if config.Period != nil {
period = *config.Period
}
var agent agent.Agent
if err := context.Get(config.AgentName, &agent); err != nil {
return nil, err
}
var metricFactory spool.MetricFactory
err := context.Get(config.MetricSpoolName, &metricFactory)
if err != nil {
return nil, err
}
var charmdir fortress.Guest
err = context.Get(config.CharmDirName, &charmdir)
if err != nil {
return nil, err
}
agentConfig := agent.CurrentConfig()
tag := agentConfig.Tag()
unitTag, ok := tag.(names.UnitTag)
if !ok {
return nil, errors.Errorf("expected a unit tag, got %v", tag)
}
paths := uniter.NewWorkerPaths(agentConfig.DataDir(), unitTag, "metrics-collect")
runner := &hookRunner{
unitTag: unitTag.String(),
paths: paths,
}
var listener stopper
charmURL, validMetrics, err := readCharm(unitTag, paths)
if err != nil {
return nil, errors.Trace(err)
}
if len(validMetrics) > 0 && charmURL.Schema == "local" {
h := newHandler(handlerConfig{
unitTag: unitTag,
charmURL: charmURL,
validMetrics: validMetrics,
metricsFactory: metricFactory,
runner: runner,
})
listener, err = newSocketListener(socketName(paths.State.BaseDir, unitTag.String()), h)
if err != nil {
return nil, err
}
}
collector := &collect{
period: period,
agent: agent,
metricFactory: metricFactory,
charmdir: charmdir,
listener: listener,
runner: runner,
}
return collector, nil
}