func (s *ContextFactorySuite) SetUpTest(c *gc.C) {
s.HookContextSuite.SetUpTest(c)
s.paths = NewRealPaths(c)
s.membership = map[int][]string{}
contextFactory, err := runner.NewContextFactory(
s.uniter,
s.unit.Tag().(names.UnitTag),
fakeTracker{},
s.getRelationInfos,
s.storage,
s.paths,
)
c.Assert(err, jc.ErrorIsNil)
s.factory = contextFactory
}
func (u *Uniter) init(unitTag names.UnitTag) (err error) {
u.unit, err = u.st.Unit(unitTag)
if err != nil {
return err
}
if u.unit.Life() == params.Dead {
// If we started up already dead, we should not progress further. If we
// become Dead immediately after starting up, we may well complete any
// operations in progress before detecting it; but that race is fundamental
// and inescapable, whereas this one is not.
return worker.ErrTerminateAgent
}
if err = u.setupLocks(); err != nil {
return err
}
if err := jujuc.EnsureSymlinks(u.paths.ToolsDir); err != nil {
return err
}
if err := os.MkdirAll(u.paths.State.RelationsDir, 0755); err != nil {
return errors.Trace(err)
}
relations, err := newRelations(u.st, unitTag, u.paths, u.tomb.Dying())
if err != nil {
return errors.Annotatef(err, "cannot create relations")
}
u.relations = relations
storageAttachments, err := storage.NewAttachments(
u.st, unitTag, u.paths.State.StorageDir, u.tomb.Dying(),
)
if err != nil {
return errors.Annotatef(err, "cannot create storage hook source")
}
u.storage = storageAttachments
u.addCleanup(storageAttachments.Stop)
deployer, err := charm.NewDeployer(
u.paths.State.CharmDir,
u.paths.State.DeployerDir,
charm.NewBundlesDir(u.paths.State.BundlesDir),
)
if err != nil {
return errors.Annotatef(err, "cannot create deployer")
}
u.deployer = &deployerProxy{deployer}
contextFactory, err := runner.NewContextFactory(
u.st, unitTag, u.leadershipTracker, u.relations.GetInfo, u.storage, u.paths,
)
if err != nil {
return err
}
runnerFactory, err := runner.NewFactory(
u.st, u.paths, contextFactory,
)
if err != nil {
return err
}
u.operationFactory = operation.NewFactory(operation.FactoryParams{
Deployer: u.deployer,
RunnerFactory: runnerFactory,
Callbacks: &operationCallbacks{u},
StorageUpdater: u.storage,
Abort: u.tomb.Dying(),
MetricSender: u.unit,
MetricSpoolDir: u.paths.GetMetricsSpoolDir(),
})
operationExecutor, err := u.newOperationExecutor(u.paths.State.OperationsFile, u.getServiceCharmURL, u.acquireExecutionLock)
if err != nil {
return err
}
u.operationExecutor = operationExecutor
logger.Debugf("starting juju-run listener on unix:%s", u.paths.Runtime.JujuRunSocket)
u.runListener, err = NewRunListener(u, u.paths.Runtime.JujuRunSocket)
if err != nil {
return err
}
u.addCleanup(func() error {
// TODO(fwereade): RunListener returns no error on Close. This seems wrong.
u.runListener.Close()
return nil
})
// The socket needs to have permissions 777 in order for other users to use it.
if version.Current.OS != version.Windows {
return os.Chmod(u.paths.Runtime.JujuRunSocket, 0777)
}
return nil
}
func (s *FactorySuite) TestNewHookRunnerWithStorage(c *gc.C) {
// We need to set up a unit that has storage metadata defined.
ch := s.AddTestingCharm(c, "storage-block")
sCons := map[string]state.StorageConstraints{
"data": {Pool: "", Size: 1024, Count: 1},
}
service := s.AddTestingServiceWithStorage(c, "storage-block", ch, sCons)
s.machine = nil // allocate a new machine
unit := s.AddUnit(c, service)
storageAttachments, err := s.State.UnitStorageAttachments(unit.UnitTag())
c.Assert(err, jc.ErrorIsNil)
c.Assert(storageAttachments, gc.HasLen, 1)
storageTag := storageAttachments[0].StorageInstance()
volume, err := s.State.StorageInstanceVolume(storageTag)
c.Assert(err, jc.ErrorIsNil)
volumeTag := volume.VolumeTag()
machineTag := s.machine.MachineTag()
err = s.State.SetVolumeInfo(
volumeTag, state.VolumeInfo{
VolumeId: "vol-123",
Size: 456,
},
)
c.Assert(err, jc.ErrorIsNil)
err = s.State.SetVolumeAttachmentInfo(
machineTag, volumeTag, state.VolumeAttachmentInfo{
DeviceName: "sdb",
},
)
c.Assert(err, jc.ErrorIsNil)
password, err := utils.RandomPassword()
err = unit.SetPassword(password)
c.Assert(err, jc.ErrorIsNil)
st := s.OpenAPIAs(c, unit.Tag(), password)
uniter, err := st.Uniter()
c.Assert(err, jc.ErrorIsNil)
contextFactory, err := runner.NewContextFactory(
uniter,
unit.Tag().(names.UnitTag),
fakeTracker{},
s.getRelationInfos,
s.storage,
s.paths,
)
c.Assert(err, jc.ErrorIsNil)
factory, err := runner.NewFactory(
uniter,
s.paths,
contextFactory,
)
c.Assert(err, jc.ErrorIsNil)
rnr, err := factory.NewHookRunner(hook.Info{
Kind: hooks.StorageAttached,
StorageId: "data/0",
})
c.Assert(err, jc.ErrorIsNil)
s.AssertPaths(c, rnr)
ctx := rnr.Context()
c.Assert(ctx.UnitName(), gc.Equals, "storage-block/0")
s.AssertStorageContext(c, ctx, "data/0", storage.StorageAttachmentInfo{
Kind: storage.StorageKindBlock,
Location: "/dev/sdb",
})
s.AssertNotActionContext(c, ctx)
s.AssertNotRelationContext(c, ctx)
}
