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) }