// Manifold returns a dependency manifold that runs a logger // worker, using the resource names defined in the supplied config. func Manifold(config ManifoldConfig) dependency.Manifold { newWorker := func(a agent.Agent, apiCaller base.APICaller) (worker.Worker, error) { return New(config.LogSource, logsender.NewAPI(apiCaller)), nil } return util.PostUpgradeManifold(config.PostUpgradeManifoldConfig, newWorker) }
func (s *PostUpgradeManifoldSuite) SetUpTest(c *gc.C) { s.IsolationSuite.SetUpTest(c) s.Stub = testing.Stub{} s.worker = &dummyWorker{} s.manifold = util.PostUpgradeManifold(util.PostUpgradeManifoldConfig{ AgentName: "agent-name", APICallerName: "api-caller-name", UpgradeWaiterName: "upgradewaiter-name", }, s.newWorker) }
// Manifold returns a dependency manifold that runs a deployer worker, // using the resource names defined in the supplied config. func Manifold(config ManifoldConfig) dependency.Manifold { // newWorker trivially wraps NewDeployer for use in a util.PostUpgradeManifold. // // It's not tested at the moment, because the scaffolding // necessary is too unwieldy/distracting to introduce at this point. newWorker := func(a agent.Agent, apiCaller base.APICaller) (worker.Worker, error) { cfg := a.CurrentConfig() // Grab the tag and ensure that it's for a machine. tag, ok := cfg.Tag().(names.MachineTag) if !ok { return nil, errors.New("agent's tag is not a machine tag") } // Get the machine agent's jobs. // TODO(fwereade): this functionality should be on the // deployer facade instead. agentFacade := apiagent.NewState(apiCaller) entity, err := agentFacade.Entity(tag) if err != nil { return nil, err } var isUnitHoster bool for _, job := range entity.Jobs() { if job == multiwatcher.JobHostUnits { isUnitHoster = true break } } if !isUnitHoster { return nil, dependency.ErrUninstall } deployerFacade := apideployer.NewState(apiCaller) context := config.NewDeployContext(deployerFacade, cfg) w, err := NewDeployer(deployerFacade, context) if err != nil { return nil, errors.Annotate(err, "cannot start unit agent deployer worker") } return w, nil } return util.PostUpgradeManifold(config.PostUpgradeManifoldConfig, newWorker) }
// Manifold returns a dependency manifold that runs a machiner worker, using // the resource names defined in the supplied config. func Manifold(config ManifoldConfig) dependency.Manifold { // TODO(waigani) This function is currently covered by functional tests // under the machine agent. Add unit tests once infrastructure to do so is // in place. // newWorker non-trivially wraps NewMachiner to specialise a PostUpgradeManifold. var newWorker = func(a agent.Agent, apiCaller base.APICaller) (worker.Worker, error) { currentConfig := a.CurrentConfig() // TODO(fwereade): this functionality should be on the // deployer facade instead. agentFacade := apiagent.NewState(apiCaller) envConfig, err := agentFacade.ModelConfig() if err != nil { return nil, errors.Errorf("cannot read environment config: %v", err) } ignoreMachineAddresses, _ := envConfig.IgnoreMachineAddresses() // Containers only have machine addresses, so we can't ignore them. tag := currentConfig.Tag() if names.IsContainerMachine(tag.Id()) { ignoreMachineAddresses = false } if ignoreMachineAddresses { logger.Infof("machine addresses not used, only addresses from provider") } accessor := APIMachineAccessor{apimachiner.NewState(apiCaller)} w, err := NewMachiner(Config{ MachineAccessor: accessor, Tag: tag.(names.MachineTag), ClearMachineAddressesOnStart: ignoreMachineAddresses, NotifyMachineDead: func() error { return agent.SetCanUninstall(a) }, }) if err != nil { return nil, errors.Annotate(err, "cannot start machiner worker") } return w, err } return util.PostUpgradeManifold(config.PostUpgradeManifoldConfig, newWorker) }
func (s *PostUpgradeManifoldSuite) TestUpgradeWaitNotRequired(c *gc.C) { manifold := util.PostUpgradeManifold(util.PostUpgradeManifoldConfig{ AgentName: "agent-name", APICallerName: "api-caller-name", UpgradeWaiterName: util.UpgradeWaitNotRequired, }, s.newWorker) c.Check(manifold.Inputs, jc.DeepEquals, []string{"agent-name", "api-caller-name"}) expectAgent := &dummyAgent{} expectApiCaller := &dummyApiCaller{} getResource := dt.StubGetResource(dt.StubResources{ "agent-name": dt.StubResource{Output: expectAgent}, "api-caller-name": dt.StubResource{Output: expectApiCaller}, }) worker, err := manifold.Start(getResource) c.Check(err, jc.ErrorIsNil) c.Check(worker, gc.Equals, s.worker) s.CheckCalls(c, []testing.StubCall{{ FuncName: "newWorker", Args: []interface{}{expectAgent, expectApiCaller}, }}) }
// MachineManifold returns a dependency.Manifold that runs a storage provisioner. func MachineManifold(config MachineManifoldConfig) dependency.Manifold { newWorker := func(a agent.Agent, apiCaller base.APICaller) (worker.Worker, error) { if config.Clock == nil { return nil, dependency.ErrMissing } cfg := a.CurrentConfig() api, err := storageprovisioner.NewState(apiCaller, cfg.Tag()) if err != nil { return nil, errors.Trace(err) } tag, ok := cfg.Tag().(names.MachineTag) if !ok { return nil, errors.Errorf("this manifold may only be used inside a machine agent") } storageDir := filepath.Join(cfg.DataDir(), "storage") w, err := NewStorageProvisioner(Config{ Scope: tag, StorageDir: storageDir, Volumes: api, Filesystems: api, Life: api, Environ: api, Machines: api, Status: api, Clock: config.Clock, }) if err != nil { return nil, errors.Trace(err) } return w, nil } return util.PostUpgradeManifold(config.PostUpgradeManifoldConfig, newWorker) }
// Manifold returns a dependency manifold that runs a logger // worker, using the resource names defined in the supplied config. func Manifold(config ManifoldConfig) dependency.Manifold { return util.PostUpgradeManifold(util.PostUpgradeManifoldConfig(config), newWorker) }