func (s *deployerSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
s.stateAPI, s.machine = s.OpenAPIAsNewMachine(c, state.JobManageModel, state.JobHostUnits)
err := s.machine.SetProviderAddresses(network.NewAddress("0.1.2.3"))
c.Assert(err, jc.ErrorIsNil)
// Create the needed services and relate them.
s.service0 = s.AddTestingService(c, "mysql", s.AddTestingCharm(c, "mysql"))
s.service1 = s.AddTestingService(c, "logging", s.AddTestingCharm(c, "logging"))
eps, err := s.State.InferEndpoints("mysql", "logging")
c.Assert(err, jc.ErrorIsNil)
rel, err := s.State.AddRelation(eps...)
c.Assert(err, jc.ErrorIsNil)
// Create principal and subordinate units and assign them.
s.principal, err = s.service0.AddUnit()
c.Assert(err, jc.ErrorIsNil)
err = s.principal.AssignToMachine(s.machine)
c.Assert(err, jc.ErrorIsNil)
relUnit, err := rel.Unit(s.principal)
c.Assert(err, jc.ErrorIsNil)
err = relUnit.EnterScope(nil)
c.Assert(err, jc.ErrorIsNil)
s.subordinate, err = s.State.Unit("logging/0")
c.Assert(err, jc.ErrorIsNil)
// Create the deployer facade.
s.st = deployer.NewState(s.stateAPI)
c.Assert(s.st, gc.NotNil)
s.APIAddresserTests = apitesting.NewAPIAddresserTests(s.st, s.BackingState)
}
func (s *deployerSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
s.SimpleToolsFixture.SetUp(c, s.DataDir())
s.stateAPI, s.machine = s.OpenAPIAsNewMachine(c)
// Create the deployer facade.
s.deployerState = apideployer.NewState(s.stateAPI)
c.Assert(s.deployerState, gc.NotNil)
}
// 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)
}
// newWorker trivially wraps NewDeployer for use in a engine.AgentApiManifold.
//
// It's not tested at the moment, because the scaffolding
// necessary is too unwieldy/distracting to introduce at this point.
func (config ManifoldConfig) newWorker(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
}
// Deployer returns access to the Deployer API
func (st *State) Deployer() *deployer.State {
return deployer.NewState(st)
}
// Note: This is really meant as a unit-test, this isn't a test that
// should need all of the setup we have for this test suite
func (s *deployerSuite) TestNew(c *gc.C) {
deployer := deployer.NewState(s.stateAPI)
c.Assert(deployer, gc.NotNil)
}
