// runInitialiser runs the container initialiser with the initialisation hook held.
func (cs *ContainerSetup) runInitialiser(containerType instance.ContainerType, initialiser container.Initialiser) error {
if err := cs.initLock.Lock(fmt.Sprintf("initialise-%s", containerType)); err != nil {
return fmt.Errorf("failed to acquire initialization lock: %v", err)
}
defer cs.initLock.Unlock()
return initialiser.Initialise()
}
// runInitialiser runs the container initialiser with the initialisation hook held.
func (cs *ContainerSetup) runInitialiser(containerType instance.ContainerType, initialiser container.Initialiser) error {
logger.Debugf("running initialiser for %s containers", containerType)
if err := cs.initLock.Lock(fmt.Sprintf("initialise-%s", containerType)); err != nil {
return errors.Annotate(err, "failed to acquire initialization lock")
}
defer cs.initLock.Unlock()
// Only tweak default LXC network config when address allocation
// feature flag is enabled.
if environs.AddressAllocationEnabled() {
// In order to guarantee stable statically assigned IP addresses
// for LXC containers, we need to install a custom version of
// /etc/default/lxc-net before we install the lxc package. The
// custom version of lxc-net is almost the same as the original,
// but the defined LXC_DHCP_RANGE (used by dnsmasq to give away
// 10.0.3.x addresses to containers bound to lxcbr0) has infinite
// lease time. This is necessary, because with the default lease
// time of 1h, dhclient running inside each container will request
// a renewal from dnsmasq and replace our statically configured IP
// address within an hour after starting the container.
err := maybeOverrideDefaultLXCNet(containerType, cs.addressableContainers)
if err != nil {
return errors.Trace(err)
}
}
if err := initialiser.Initialise(); err != nil {
return errors.Trace(err)
}
return nil
}
// runInitialiser runs the container initialiser with the initialisation hook held.
func (cs *ContainerSetup) runInitialiser(abort <-chan struct{}, containerType instance.ContainerType, initialiser container.Initialiser) error {
logger.Debugf("running initialiser for %s containers", containerType)
spec := mutex.Spec{
Name: cs.initLockName,
Clock: clock.WallClock,
// If we don't get the lock straigh away, there is no point trying multiple
// times per second for an operation that is likelty to take multiple seconds.
Delay: time.Second,
Cancel: abort,
}
logger.Debugf("acquire lock %q for container initialisation", cs.initLockName)
releaser, err := mutex.Acquire(spec)
if err != nil {
return errors.Annotate(err, "failed to acquire initialization lock")
}
logger.Debugf("lock %q acquired", cs.initLockName)
defer logger.Debugf("release lock %q for container initialisation", cs.initLockName)
defer releaser.Release()
if err := initialiser.Initialise(); err != nil {
return errors.Trace(err)
}
return nil
}
// runInitialiser runs the container initialiser with the initialisation hook held.
func (cs *ContainerSetup) runInitialiser(containerType instance.ContainerType, initialiser container.Initialiser) error {
logger.Debugf("running initialiser for %s containers", containerType)
if err := cs.initLock.Lock(fmt.Sprintf("initialise-%s", containerType)); err != nil {
return errors.Annotate(err, "failed to acquire initialization lock")
}
defer cs.initLock.Unlock()
return initialiser.Initialise()
}