func (s *ContextFactorySuite) SetUpTest(c *gc.C) {
s.HookContextSuite.SetUpTest(c)
s.paths = runnertesting.NewRealPaths(c)
s.membership = map[int][]string{}
contextFactory, err := context.NewContextFactory(
s.uniter,
s.unit.Tag().(names.UnitTag),
runnertesting.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 := relation.NewRelations(
u.st, unitTag, u.paths.State.CharmDir,
u.paths.State.RelationsDir, u.catacomb.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.catacomb.Dying(),
)
if err != nil {
return errors.Annotatef(err, "cannot create storage hook source")
}
u.storage = storageAttachments
u.commands = runcommands.NewCommands()
u.commandChannel = make(chan string)
deployer, err := charm.NewDeployer(
u.paths.State.CharmDir,
u.paths.State.DeployerDir,
charm.NewBundlesDir(u.paths.State.BundlesDir, u.downloader),
)
if err != nil {
return errors.Annotatef(err, "cannot create deployer")
}
u.deployer = &deployerProxy{deployer}
contextFactory, err := context.NewContextFactory(
u.st, unitTag, u.leadershipTracker, u.relations.GetInfo, u.storage, u.paths, u.clock,
)
if err != nil {
return err
}
runnerFactory, err := runner.NewFactory(
u.st, u.paths, contextFactory,
)
if err != nil {
return errors.Trace(err)
}
u.operationFactory = operation.NewFactory(operation.FactoryParams{
Deployer: u.deployer,
RunnerFactory: runnerFactory,
Callbacks: &operationCallbacks{u},
Abort: u.catacomb.Dying(),
MetricSpoolDir: u.paths.GetMetricsSpoolDir(),
})
operationExecutor, err := u.newOperationExecutor(u.paths.State.OperationsFile, u.getServiceCharmURL, u.acquireExecutionLock)
if err != nil {
return errors.Trace(err)
}
u.operationExecutor = operationExecutor
logger.Debugf("starting juju-run listener on unix:%s", u.paths.Runtime.JujuRunSocket)
commandRunner, err := NewChannelCommandRunner(ChannelCommandRunnerConfig{
Abort: u.catacomb.Dying(),
Commands: u.commands,
CommandChannel: u.commandChannel,
})
if err != nil {
return errors.Annotate(err, "creating command runner")
}
u.runListener, err = NewRunListener(RunListenerConfig{
SocketPath: u.paths.Runtime.JujuRunSocket,
CommandRunner: commandRunner,
})
if err != nil {
return errors.Trace(err)
}
rlw := newRunListenerWrapper(u.runListener)
if err := u.catacomb.Add(rlw); err != nil {
return errors.Trace(err)
}
// The socket needs to have permissions 777 in order for other users to use it.
if jujuos.HostOS() != jujuos.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 := context.NewContextFactory(
uniter,
unit.Tag().(names.UnitTag),
runnertesting.FakeTracker{},
s.getRelationInfos,
s.storage,
s.paths,
testing.NewClock(time.Time{}),
)
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")
}
func (s *ContextSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
s.machine = nil
ch := s.AddTestingCharm(c, "wordpress")
s.service = s.AddTestingService(c, "u", ch)
s.unit = s.AddUnit(c, s.service)
storageData0 := names.NewStorageTag("data/0")
s.storage = &runnertesting.StorageContextAccessor{
map[names.StorageTag]*runnertesting.ContextStorage{
storageData0: &runnertesting.ContextStorage{
storageData0,
storage.StorageKindBlock,
"/dev/sdb",
},
},
}
password, err := utils.RandomPassword()
err = s.unit.SetPassword(password)
c.Assert(err, jc.ErrorIsNil)
s.st = s.OpenAPIAs(c, s.unit.Tag(), password)
s.uniter, err = s.st.Uniter()
c.Assert(err, jc.ErrorIsNil)
c.Assert(s.uniter, gc.NotNil)
s.apiUnit, err = s.uniter.Unit(s.unit.Tag().(names.UnitTag))
c.Assert(err, jc.ErrorIsNil)
s.paths = runnertesting.NewRealPaths(c)
s.membership = map[int][]string{}
// Note: The unit must always have a charm URL set, because this
// happens as part of the installation process (that happens
// before the initial install hook).
err = s.unit.SetCharmURL(ch.URL())
c.Assert(err, jc.ErrorIsNil)
s.relch = s.AddTestingCharm(c, "mysql")
s.relunits = map[int]*state.RelationUnit{}
s.apiRelunits = map[int]*uniter.RelationUnit{}
s.AddContextRelation(c, "db0")
s.AddContextRelation(c, "db1")
s.contextFactory, err = context.NewContextFactory(
s.uniter,
s.unit.Tag().(names.UnitTag),
runnertesting.FakeTracker{},
s.getRelationInfos,
s.storage,
s.paths,
)
c.Assert(err, jc.ErrorIsNil)
factory, err := runner.NewFactory(
s.uniter,
s.paths,
s.contextFactory,
)
c.Assert(err, jc.ErrorIsNil)
s.factory = factory
}
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 initialising for the first time after deploying, update the status.
currentStatus, err := u.unit.UnitStatus()
if err != nil {
return err
}
// TODO(fwereade/wallyworld): we should have an explicit place in the model
// to tell us when we've hit this point, instead of piggybacking on top of
// status and/or status history.
// If the previous status was waiting for machine, we transition to the next step.
if currentStatus.Status == string(status.Waiting) &&
(currentStatus.Info == status.MessageWaitForMachine || currentStatus.Info == status.MessageInstallingAgent) {
if err := u.unit.SetUnitStatus(status.Waiting, status.MessageInitializingAgent, nil); err != nil {
return errors.Trace(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 := relation.NewRelations(
u.st, unitTag, u.paths.State.CharmDir,
u.paths.State.RelationsDir, u.catacomb.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.catacomb.Dying(),
)
if err != nil {
return errors.Annotatef(err, "cannot create storage hook source")
}
u.storage = storageAttachments
u.commands = runcommands.NewCommands()
u.commandChannel = make(chan string)
deployer, err := charm.NewDeployer(
u.paths.State.CharmDir,
u.paths.State.DeployerDir,
charm.NewBundlesDir(u.paths.State.BundlesDir, u.downloader),
)
if err != nil {
return errors.Annotatef(err, "cannot create deployer")
}
contextFactory, err := context.NewContextFactory(
u.st, unitTag, u.leadershipTracker, u.relations.GetInfo, u.storage, u.paths, u.clock,
)
if err != nil {
return err
}
runnerFactory, err := runner.NewFactory(
u.st, u.paths, contextFactory,
)
if err != nil {
return errors.Trace(err)
}
u.operationFactory = operation.NewFactory(operation.FactoryParams{
Deployer: deployer,
RunnerFactory: runnerFactory,
Callbacks: &operationCallbacks{u},
Abort: u.catacomb.Dying(),
MetricSpoolDir: u.paths.GetMetricsSpoolDir(),
})
operationExecutor, err := u.newOperationExecutor(u.paths.State.OperationsFile, u.getServiceCharmURL, u.acquireExecutionLock)
if err != nil {
return errors.Trace(err)
}
u.operationExecutor = operationExecutor
logger.Debugf("starting juju-run listener on unix:%s", u.paths.Runtime.JujuRunSocket)
commandRunner, err := NewChannelCommandRunner(ChannelCommandRunnerConfig{
Abort: u.catacomb.Dying(),
Commands: u.commands,
CommandChannel: u.commandChannel,
})
if err != nil {
return errors.Annotate(err, "creating command runner")
}
u.runListener, err = NewRunListener(RunListenerConfig{
SocketPath: u.paths.Runtime.JujuRunSocket,
CommandRunner: commandRunner,
})
if err != nil {
return errors.Trace(err)
}
rlw := newRunListenerWrapper(u.runListener)
if err := u.catacomb.Add(rlw); err != nil {
return errors.Trace(err)
}
// The socket needs to have permissions 777 in order for other users to use it.
if jujuos.HostOS() != jujuos.Windows {
return os.Chmod(u.paths.Runtime.JujuRunSocket, 0777)
}
return nil
}