func maybeReleaseContainerAddresses(
api APICalls,
instanceID instance.Id,
namespace string,
log loggo.Logger,
) {
if environs.AddressAllocationEnabled() {
// The addresser worker will take care of the addresses.
return
}
// If we're not using addressable containers, we might still have used MAAS
// 1.8+ device to register the container when provisioning. In that case we
// need to attempt releasing the device, but ignore a NotSupported error
// (when we're not using MAAS 1.8+).
namespacePrefix := fmt.Sprintf("%s-", namespace)
tagString := strings.TrimPrefix(string(instanceID), namespacePrefix)
containerTag, err := names.ParseMachineTag(tagString)
if err != nil {
// Not a reason to cause StopInstances to fail though..
log.Warningf("unexpected container tag %q: %v", instanceID, err)
return
}
err = api.ReleaseContainerAddresses(containerTag)
switch {
case err == nil:
log.Infof("released all addresses for container %q", containerTag.Id())
case errors.IsNotSupported(err):
log.Warningf("not releasing all addresses for container %q: %v", containerTag.Id(), err)
default:
log.Warningf(
"unexpected error trying to release container %q addreses: %v",
containerTag.Id(), err,
)
}
}
func releaseContainerAddresses(
api APICalls,
instanceID instance.Id,
namespace instance.Namespace,
log loggo.Logger,
) {
containerTag, err := namespace.MachineTag(string(instanceID))
if err != nil {
// Not a reason to cause StopInstances to fail though..
log.Warningf("unexpected container tag %q: %v", instanceID, err)
return
}
err = api.ReleaseContainerAddresses(containerTag)
switch {
case err == nil:
log.Infof("released all addresses for container %q", containerTag.Id())
case errors.IsNotSupported(err):
log.Warningf("not releasing all addresses for container %q: %v", containerTag.Id(), err)
default:
log.Warningf(
"unexpected error trying to release container %q addreses: %v",
containerTag.Id(), err,
)
}
}
func logAllSeverities(logger loggo.Logger) {
logger.Criticalf("something critical")
logger.Errorf("an error")
logger.Warningf("a warning message")
logger.Infof("an info message")
logger.Debugf("a debug message")
logger.Tracef("a trace message")
}
// AgentDone processes the error returned by
// an exiting agent.
func AgentDone(logger loggo.Logger, err error) error {
err = errors.Cause(err)
switch err {
case worker.ErrTerminateAgent, worker.ErrRebootMachine, worker.ErrShutdownMachine:
err = nil
}
if ug, ok := err.(*upgrader.UpgradeReadyError); ok {
if err := ug.ChangeAgentTools(); err != nil {
// Return and let the init system deal with the restart.
err = errors.Annotate(err, "cannot change agent tools")
logger.Infof(err.Error())
return err
}
}
return err
}
// AgentDone processes the error returned by an exiting agent.
func AgentDone(logger loggo.Logger, err error) error {
err = errors.Cause(err)
switch err {
case worker.ErrTerminateAgent, worker.ErrRebootMachine, worker.ErrShutdownMachine:
// These errors are swallowed here because we want to exit
// the agent process without error, to avoid the init system
// restarting us.
err = nil
}
if ug, ok := err.(*upgrader.UpgradeReadyError); ok {
if err := ug.ChangeAgentTools(); err != nil {
// Return and let the init system deal with the restart.
err = errors.Annotate(err, "cannot change agent tools")
logger.Infof(err.Error())
return err
}
}
return err
}
func prepareOrGetContainerInterfaceInfo(
api APICalls,
machineID string,
bridgeDevice string,
allocateOrMaintain bool,
enableNAT bool,
startingNetworkInfo []network.InterfaceInfo,
log loggo.Logger,
providerType string,
) ([]network.InterfaceInfo, error) {
maintain := !allocateOrMaintain
if environs.AddressAllocationEnabled(providerType) {
if maintain {
log.Debugf("running maintenance for container %q", machineID)
} else {
log.Debugf("trying to allocate static IP for container %q", machineID)
}
allocatedInfo, err := configureContainerNetwork(
machineID,
bridgeDevice,
api,
startingNetworkInfo,
allocateOrMaintain,
enableNAT,
)
if err != nil && !maintain {
log.Infof("not allocating static IP for container %q: %v", machineID, err)
}
return allocatedInfo, err
}
if maintain {
log.Debugf("address allocation disabled: Not running maintenance for machine %q", machineID)
return nil, nil
}
log.Debugf("address allocation feature flag not enabled; using multi-bridge networking for container %q", machineID)
// In case we're running on MAAS 1.8+ with devices support, we'll still
// call PrepareContainerInterfaceInfo(), but we'll ignore a NotSupported
// error if we get it (which means we're not using MAAS 1.8+).
containerTag := names.NewMachineTag(machineID)
preparedInfo, err := api.PrepareContainerInterfaceInfo(containerTag)
if err != nil && errors.IsNotSupported(err) {
log.Warningf("new container %q not registered as device: not running on MAAS 1.8+", machineID)
return nil, nil
} else if err != nil {
return nil, errors.Trace(err)
}
log.Tracef("PrepareContainerInterfaceInfo returned %+v", preparedInfo)
dnsServersFound := false
for _, info := range preparedInfo {
if len(info.DNSServers) > 0 {
dnsServersFound = true
break
}
}
if !dnsServersFound {
logger.Warningf("no DNS settings found, discovering the host settings")
dnsServers, searchDomain, err := localDNSServers()
if err != nil {
return nil, errors.Trace(err)
}
// Since the result is sorted, the first entry is the primary NIC.
preparedInfo[0].DNSServers = dnsServers
preparedInfo[0].DNSSearchDomains = []string{searchDomain}
logger.Debugf(
"setting DNS servers %+v and domains %+v on container interface %q",
preparedInfo[0].DNSServers, preparedInfo[0].DNSSearchDomains, preparedInfo[0].InterfaceName,
)
}
return preparedInfo, nil
}
func prepareOrGetContainerInterfaceInfo(
api APICalls,
machineID string,
bridgeDevice string,
allocateOrMaintain bool,
enableNAT bool,
startingNetworkInfo []network.InterfaceInfo,
log loggo.Logger,
) ([]network.InterfaceInfo, error) {
maintain := !allocateOrMaintain
if environs.AddressAllocationEnabled() {
if maintain {
log.Debugf("running maintenance for container %q", machineID)
} else {
log.Debugf("trying to allocate static IP for container %q", machineID)
}
allocatedInfo, err := configureContainerNetwork(
machineID,
bridgeDevice,
api,
startingNetworkInfo,
allocateOrMaintain,
enableNAT,
)
if err != nil && !maintain {
log.Infof("not allocating static IP for container %q: %v", machineID, err)
}
return allocatedInfo, err
}
if maintain {
log.Debugf("address allocation disabled: Not running maintenance for machine %q", machineID)
return nil, nil
}
log.Debugf("address allocation feature flag not enabled; using DHCP for container %q", machineID)
// In case we're running on MAAS 1.8+ with devices support, we'll still
// call PrepareContainerInterfaceInfo(), but we'll ignore a NotSupported
// error if we get it (which means we're not using MAAS 1.8+).
containerTag := names.NewMachineTag(machineID)
preparedInfo, err := api.PrepareContainerInterfaceInfo(containerTag)
if err != nil && errors.IsNotSupported(err) {
log.Warningf("new container %q not registered as device: not running on MAAS 1.8+", machineID)
return nil, nil
} else if err != nil {
return nil, errors.Trace(err)
}
dnsServers, searchDomain, dnsErr := localDNSServers()
if dnsErr != nil {
return nil, errors.Trace(dnsErr)
}
for i, _ := range preparedInfo {
preparedInfo[i].DNSServers = dnsServers
preparedInfo[i].DNSSearch = searchDomain
}
log.Tracef("PrepareContainerInterfaceInfo returned %#v", preparedInfo)
// Most likely there will be only one item in the list, but check
// all of them for forward compatibility.
macAddresses := set.NewStrings()
for _, prepInfo := range preparedInfo {
macAddresses.Add(prepInfo.MACAddress)
}
log.Infof(
"new container %q registered as a MAAS device with MAC address(es) %v",
machineID, macAddresses.SortedValues(),
)
return preparedInfo, nil
}