// loadImage loads an os image from the blobstore,
// downloading and caching it if necessary.
func (h *imagesDownloadHandler) loadImage(st *state.State, envuuid, kind, series, arch string) (
*imagestorage.Metadata, io.ReadCloser, error,
) {
// We want to ensure that if an image needs to be downloaded and cached,
// this only happens once.
imageIdent := fmt.Sprintf("image-%s-%s-%s-%s", envuuid, kind, series, arch)
lockDir := filepath.Join(h.dataDir, "locks")
lock, err := fslock.NewLock(lockDir, imageIdent, fslock.Defaults())
if err != nil {
return nil, nil, errors.Trace(err)
}
lock.Lock("fetch and cache image " + imageIdent)
defer lock.Unlock()
storage := st.ImageStorage()
metadata, imageReader, err := storage.Image(kind, series, arch)
// Not in storage, so go fetch it.
if errors.IsNotFound(err) {
if err := h.fetchAndCacheLxcImage(storage, envuuid, series, arch); err != nil {
return nil, nil, errors.Annotate(err, "error fetching and caching image")
}
err = networkOperationWitDefaultRetries(func() error {
metadata, imageReader, err = storage.Image(string(instance.LXC), series, arch)
return err
}, "streaming os image from blobstore")()
}
if err != nil {
return nil, nil, errors.Trace(err)
}
return metadata, imageReader, nil
}
func (s *rebootSuite) SetUpTest(c *gc.C) {
var err error
template := state.MachineTemplate{
Series: coretesting.FakeDefaultSeries,
Jobs: []state.MachineJob{state.JobHostUnits},
}
s.JujuConnSuite.SetUpTest(c)
s.stateAPI, s.machine = s.OpenAPIAsNewMachine(c)
s.rebootState, err = s.stateAPI.Reboot()
c.Assert(err, jc.ErrorIsNil)
c.Assert(s.rebootState, gc.NotNil)
//Add container
s.ct, err = s.State.AddMachineInsideMachine(template, s.machine.Id(), instance.KVM)
c.Assert(err, jc.ErrorIsNil)
password, err := utils.RandomPassword()
c.Assert(err, jc.ErrorIsNil)
err = s.ct.SetPassword(password)
c.Assert(err, jc.ErrorIsNil)
err = s.ct.SetProvisioned("foo", "fake_nonce", nil)
c.Assert(err, jc.ErrorIsNil)
// Open api as container
ctState := s.OpenAPIAsMachine(c, s.ct.Tag(), password, "fake_nonce")
s.ctRebootState, err = ctState.Reboot()
c.Assert(err, jc.ErrorIsNil)
c.Assert(s.ctRebootState, gc.NotNil)
lock, err := fslock.NewLock(c.MkDir(), "fake", fslock.Defaults())
c.Assert(err, jc.ErrorIsNil)
s.lock = lock
}
func (s *ManifoldSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
s.stub = &testing.Stub{}
s.manifoldConfig = meterstatus.ManifoldConfig{
AgentName: "agent-name",
APICallerName: "apicaller-name",
MachineLockName: "machine-lock-name",
NewHookRunner: meterstatus.NewHookRunner,
NewMeterStatusAPIClient: msapi.NewClient,
NewConnectedStatusWorker: meterstatus.NewConnectedStatusWorker,
NewIsolatedStatusWorker: meterstatus.NewIsolatedStatusWorker,
}
s.manifold = meterstatus.Manifold(s.manifoldConfig)
s.dataDir = c.MkDir()
locksDir := c.MkDir()
lock, err := fslock.NewLock(locksDir, "machine-lock", fslock.Defaults())
c.Assert(err, jc.ErrorIsNil)
s.dummyResources = dt.StubResources{
"agent-name": dt.StubResource{Output: &dummyAgent{dataDir: s.dataDir}},
"apicaller-name": dt.StubResource{Output: &dummyAPICaller{}},
"machine-lock-name": dt.StubResource{Output: lock},
}
s.getResource = dt.StubGetResource(s.dummyResources)
}
func acquireEnvironmentLock(dir, operation string) (*fslock.Lock, error) {
lock, err := fslock.NewLock(dir, lockName, fslock.Defaults())
if err != nil {
return nil, errors.Trace(err)
}
message := fmt.Sprintf("pid: %d, operation: %s", os.Getpid(), operation)
err = lock.LockWithTimeout(lockTimeout, message)
if err == nil {
return lock, nil
}
if errors.Cause(err) != fslock.ErrTimeout {
return nil, errors.Trace(err)
}
logger.Warningf("breaking configstore lock, lock dir: %s", filepath.Join(dir, lockName))
logger.Warningf(" lock holder message: %s", lock.Message())
// If we are unable to acquire the lock within the lockTimeout,
// consider it broken for some reason, and break it.
err = lock.BreakLock()
if err != nil {
return nil, errors.Annotate(err, "unable to break the configstore lock")
}
err = lock.LockWithTimeout(lockTimeout, message)
if err != nil {
return nil, errors.Trace(err)
}
return lock, nil
}
func (s *store) lock(operation string) (*fslock.Lock, error) {
lockName := "controllers.lock"
lock, err := fslock.NewLock(osenv.JujuXDGDataHome(), lockName, fslock.Defaults())
if err != nil {
return nil, errors.Trace(err)
}
message := fmt.Sprintf("pid: %d, operation: %s", os.Getpid(), operation)
err = lock.LockWithTimeout(lockTimeout, message)
if err == nil {
return lock, nil
}
if errors.Cause(err) != fslock.ErrTimeout {
return nil, errors.Trace(err)
}
logger.Warningf("breaking jujuclient lock : %s", lockName)
logger.Warningf(" lock holder message: %s", lock.Message())
// If we are unable to acquire the lock within the lockTimeout,
// consider it broken for some reason, and break it.
err = lock.BreakLock()
if err != nil {
return nil, errors.Annotatef(err, "unable to break the jujuclient lock %v", lockName)
}
err = lock.LockWithTimeout(lockTimeout, message)
if err != nil {
return nil, errors.Trace(err)
}
return lock, nil
}
func acquireEnvironmentLock(operation string) (*fslock.Lock, error) {
// NOTE: any reading or writing from the directory should be done with a
// fslock to make sure we have a consistent read or write. Also worth
// noting, we should use a very short timeout.
lock, err := fslock.NewLock(osenv.JujuXDGDataHome(), lockName, fslock.Defaults())
if err != nil {
return nil, errors.Trace(err)
}
err = lock.LockWithTimeout(lockTimeout, operation)
if err != nil {
return nil, errors.Trace(err)
}
return lock, nil
}
func (s *ContainerSetupSuite) SetUpTest(c *gc.C) {
s.CommonProvisionerSuite.SetUpTest(c)
aptCmdChan := s.HookCommandOutput(&manager.CommandOutput, []byte{}, nil)
s.aptCmdChan = aptCmdChan
// Set up provisioner for the state machine.
s.agentConfig = s.AgentConfigForTag(c, names.NewMachineTag("0"))
s.p = provisioner.NewEnvironProvisioner(s.provisioner, s.agentConfig)
// Create a new container initialisation lock.
s.initLockDir = c.MkDir()
initLock, err := fslock.NewLock(s.initLockDir, "container-init", fslock.Defaults())
c.Assert(err, jc.ErrorIsNil)
s.initLock = initLock
// Patch to isolate the test from the host machine.
s.fakeLXCNet = filepath.Join(c.MkDir(), "lxc-net")
s.PatchValue(provisioner.EtcDefaultLXCNetPath, s.fakeLXCNet)
}
func (s startUniter) step(c *gc.C, ctx *context) {
if s.unitTag == "" {
s.unitTag = "unit-u-0"
}
if ctx.uniter != nil {
panic("don't start two uniters!")
}
if ctx.api == nil {
panic("API connection not established")
}
tag, err := names.ParseUnitTag(s.unitTag)
if err != nil {
panic(err.Error())
}
downloader := api.NewCharmDownloader(ctx.apiConn.Client())
locksDir := filepath.Join(ctx.dataDir, "locks")
lock, err := fslock.NewLock(locksDir, "uniter-hook-execution", fslock.Defaults())
c.Assert(err, jc.ErrorIsNil)
operationExecutor := operation.NewExecutor
if s.newExecutorFunc != nil {
operationExecutor = s.newExecutorFunc
}
uniterParams := uniter.UniterParams{
UniterFacade: ctx.api,
UnitTag: tag,
LeadershipTracker: ctx.leaderTracker,
CharmDirGuard: ctx.charmDirGuard,
DataDir: ctx.dataDir,
Downloader: downloader,
MachineLock: lock,
UpdateStatusSignal: ctx.updateStatusHookTicker.ReturnTimer,
NewOperationExecutor: operationExecutor,
Observer: ctx,
// TODO(axw) 2015-11-02 #1512191
// update tests that rely on timing to advance clock
// appropriately.
Clock: clock.WallClock,
}
ctx.uniter, err = uniter.NewUniter(&uniterParams)
c.Assert(err, jc.ErrorIsNil)
}
func (s *ManifoldSuite) SetUpTest(c *gc.C) {
s.IsolationSuite.SetUpTest(c)
s.Stub = testing.Stub{}
s.manifold = machinelock.Manifold(machinelock.ManifoldConfig{
AgentName: "agent-name",
})
s.getResource = dt.StubGetResource(dt.StubResources{
"agent-name": dt.StubResource{Output: &dummyAgent{}},
})
lock, err := fslock.NewLock(c.MkDir(), "test-lock", fslock.Defaults())
c.Assert(err, jc.ErrorIsNil)
s.lock = lock
s.PatchValue(machinelock.CreateLock, func(dataDir string) (*fslock.Lock, error) {
s.AddCall("createLock", dataDir)
if err := s.NextErr(); err != nil {
return nil, err
}
return s.lock, nil
})
}
// HookExecutionLock returns an *fslock.Lock suitable for use as a
// unit hook execution lock. Other workers may also use this lock if
// they require isolation from hook execution.
func HookExecutionLock(dataDir string) (*fslock.Lock, error) {
lockDir := filepath.Join(dataDir, "locks")
return fslock.NewLock(lockDir, "uniter-hook-execution", fslock.Defaults())
}
func createHookLock(c *gc.C, dataDir string) *fslock.Lock {
lockDir := filepath.Join(dataDir, "locks")
lock, err := fslock.NewLock(lockDir, "uniter-hook-execution", fslock.Defaults())
c.Assert(err, jc.ErrorIsNil)
return lock
}
func (s *fslockSuite) SetUpTest(c *gc.C) {
s.lockConfig = fslock.Defaults()
s.lockConfig.Clock = &fastclock{c}
}
func (f *fastclock) After(duration time.Duration) <-chan time.Time {
f.c.Check(duration, gc.Equals, fslock.Defaults().WaitDelay)
return time.After(time.Millisecond)
}