func (s *SubnetSuite) TestPickNewAddressRace(c *gc.C) {
// represents 192.168.1.0
initialIP := uint32(3232235776)
var index int32 = -1
addresses := []uint32{initialIP, initialIP, initialIP + 1}
// the first two calls will get the same address (which simulates the
// inherent race condition in the code). The third call will get
// a new one. We should see two different addresses come out of the
// two calls: i.e. we will have detected the race condition and tried
// again.
mockPickAddress := func(_, _ uint32, _ map[uint32]bool) uint32 {
theIndex := atomic.AddInt32(&index, 1)
return addresses[theIndex]
}
s.PatchValue(&state.PickAddress, &mockPickAddress)
// 192.168.1.0 and 192.168.1.1 are the only valid addresses
subnet := s.addSubnetWithAllocatableIPHigh(c, "192.168.1.1")
waiter := sync.WaitGroup{}
waiter.Add(2)
var firstResult *state.IPAddress
var firstError error
var secondResult *state.IPAddress
var secondError error
go func() {
firstResult, firstError = subnet.PickNewAddress()
waiter.Done()
}()
go func() {
secondResult, secondError = subnet.PickNewAddress()
waiter.Done()
}()
waiter.Wait()
c.Assert(firstError, jc.ErrorIsNil)
c.Assert(secondError, jc.ErrorIsNil)
c.Assert(firstResult, gc.NotNil)
c.Assert(secondResult, gc.NotNil)
ipAddresses := []string{firstResult.Value(), secondResult.Value()}
sort.Strings(ipAddresses)
expected := []string{"192.168.1.0", "192.168.1.1"}
c.Assert(ipAddresses, jc.DeepEquals, expected)
}
func (a *addresserHandler) releaseIPAddress(addr *state.IPAddress) (err error) {
defer errors.DeferredAnnotatef(&err, "failed to release address %v", addr.Value())
logger.Debugf("attempting to release dead address %#v", addr.Value())
subnetId := network.Id(addr.SubnetId())
for attempt := common.ShortAttempt.Start(); attempt.Next(); {
err = a.releaser.ReleaseAddress(addr.InstanceId(), subnetId, addr.Address(), addr.MACAddress())
if err == nil {
return nil
}
}
// Don't remove the address from state so we
// can retry releasing the address later.
logger.Warningf("cannot release address %q: %v (will retry)", addr.Value(), err)
return errors.Trace(err)
}
// legacyPrepareOrGetContainerInterfaceInfo optionally allocates an address and
// returns information for configuring networking on a container. It accepts
// container tags as arguments.
func (p *ProvisionerAPI) legacyPrepareOrGetContainerInterfaceInfo(
args params.Entities,
provisionContainer bool,
) (
params.MachineNetworkConfigResults,
error,
) {
result := params.MachineNetworkConfigResults{
Results: make([]params.MachineNetworkConfigResult, len(args.Entities)),
}
// Some preparations first.
environ, host, canAccess, err := p.prepareContainerAccessEnvironment()
if err != nil {
return result, errors.Trace(err)
}
instId, err := host.InstanceId()
if err != nil && errors.IsNotProvisioned(err) {
// If the host machine is not provisioned yet, we have nothing
// to do. NotProvisionedf will append " not provisioned" to
// the message.
err = errors.NotProvisionedf("cannot allocate addresses: host machine %q", host)
return result, err
}
var subnet *state.Subnet
var subnetInfo network.SubnetInfo
var interfaceInfo network.InterfaceInfo
if environs.AddressAllocationEnabled() {
// We don't need a subnet unless we need to allocate a static IP.
subnet, subnetInfo, interfaceInfo, err = p.prepareAllocationNetwork(environ, instId)
if err != nil {
return result, errors.Annotate(err, "cannot allocate addresses")
}
} else {
var allInterfaceInfos []network.InterfaceInfo
allInterfaceInfos, err = environ.NetworkInterfaces(instId)
if err != nil {
return result, errors.Annotatef(err, "cannot instance %q interfaces", instId)
} else if len(allInterfaceInfos) == 0 {
return result, errors.New("no interfaces available")
}
// Currently we only support a single NIC per container, so we only need
// the information from the host instance's first NIC.
logger.Tracef("interfaces for instance %q: %v", instId, allInterfaceInfos)
interfaceInfo = allInterfaceInfos[0]
}
// Loop over the passed container tags.
for i, entity := range args.Entities {
tag, err := names.ParseMachineTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
// The auth function (canAccess) checks that the machine is a
// top level machine (we filter those out next) or that the
// machine has the host as a parent.
container, err := p.getMachine(canAccess, tag)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
} else if !container.IsContainer() {
err = errors.Errorf("cannot allocate address for %q: not a container", tag)
result.Results[i].Error = common.ServerError(err)
continue
} else if ciid, cerr := container.InstanceId(); provisionContainer == true && cerr == nil {
// Since we want to configure and create NICs on the
// container before it starts, it must also be not
// provisioned yet.
err = errors.Errorf("container %q already provisioned as %q", container, ciid)
result.Results[i].Error = common.ServerError(err)
continue
} else if cerr != nil && !errors.IsNotProvisioned(cerr) {
// Any other error needs to be reported.
result.Results[i].Error = common.ServerError(cerr)
continue
}
var macAddress string
var address *state.IPAddress
if provisionContainer {
// Allocate and set an address.
macAddress = generateMACAddress()
address, err = p.allocateAddress(environ, subnet, host, container, instId, macAddress)
if err != nil {
err = errors.Annotatef(err, "failed to allocate an address for %q", container)
result.Results[i].Error = common.ServerError(err)
continue
}
} else {
id := container.Id()
addresses, err := p.st.AllocatedIPAddresses(id)
if err != nil {
logger.Warningf("failed to get Id for container %q: %v", tag, err)
result.Results[i].Error = common.ServerError(err)
continue
}
// TODO(dooferlad): if we get more than 1 address back, we ignore everything after
// the first. The calling function expects exactly one result though,
// so we don't appear to have a way of allocating >1 address to a
// container...
if len(addresses) != 1 {
logger.Warningf("got %d addresses for container %q - expected 1: %v", len(addresses), tag, err)
result.Results[i].Error = common.ServerError(err)
continue
}
address = addresses[0]
macAddress = address.MACAddress()
}
// Store it on the machine, construct and set an interface result.
dnsServers := make([]string, len(interfaceInfo.DNSServers))
for l, dns := range interfaceInfo.DNSServers {
dnsServers[l] = dns.Value
}
if macAddress == "" {
macAddress = interfaceInfo.MACAddress
}
interfaceType := string(interfaceInfo.InterfaceType)
if interfaceType == "" {
interfaceType = string(network.EthernetInterface)
}
// TODO(dimitern): Support allocating one address per NIC on
// the host, effectively creating the same number of NICs in
// the container.
result.Results[i] = params.MachineNetworkConfigResult{
Config: []params.NetworkConfig{{
DeviceIndex: interfaceInfo.DeviceIndex,
MACAddress: macAddress,
CIDR: subnetInfo.CIDR,
NetworkName: interfaceInfo.NetworkName,
ProviderId: string(interfaceInfo.ProviderId),
ProviderSubnetId: string(subnetInfo.ProviderId),
VLANTag: interfaceInfo.VLANTag,
InterfaceType: interfaceType,
InterfaceName: interfaceInfo.InterfaceName,
Disabled: interfaceInfo.Disabled,
NoAutoStart: interfaceInfo.NoAutoStart,
DNSServers: dnsServers,
ConfigType: string(network.ConfigStatic),
Address: address.Value(),
GatewayAddress: interfaceInfo.GatewayAddress.Value,
ExtraConfig: interfaceInfo.ExtraConfig,
}},
}
}
return result, nil
}
// setAllocatedOrRelease tries to associate the newly allocated
// address addr with the container. On failure it makes the best
// effort to cleanup and release addr, logging issues along the way.
func (p *ProvisionerAPI) setAllocatedOrRelease(
addr *state.IPAddress,
environ environs.NetworkingEnviron,
instId instance.Id,
container *state.Machine,
subnetId network.Id,
macAddress string,
) (err error) {
defer func() {
if errors.Cause(err) == nil {
// Success!
return
}
logger.Warningf(
"failed to mark address %q as %q to container %q: %v (releasing and retrying)",
addr.String(), state.AddressStateAllocated, container, err,
)
// It's as good as unavailable for us, so mark it as
// such.
err = setAddrState(addr, state.AddressStateUnavailable)
if err != nil {
logger.Warningf(
"cannot set address %q to %q: %v (ignoring and releasing)",
addr.String(), state.AddressStateUnavailable, err,
)
}
err = environ.ReleaseAddress(instId, subnetId, addr.Address(), addr.MACAddress(), "")
if err == nil {
logger.Infof("address %q released; trying to allocate new", addr.String())
return
}
logger.Warningf(
"failed to release address %q on instance %q and subnet %q: %v (ignoring and retrying)",
addr.String(), instId, subnetId, err,
)
}()
// Any errors returned below will trigger the release/cleanup
// steps above.
if err = allocateAddrTo(addr, container, macAddress); err != nil {
return errors.Trace(err)
}
if err = setAddrsTo(addr, container); err != nil {
return errors.Trace(err)
}
logger.Infof("assigned address %q to container %q", addr.String(), container)
return nil
}
func (s *IPAddressSuite) assertAddress(
c *gc.C,
ipAddr *state.IPAddress,
addr network.Address,
ipState state.AddressState,
machineId, ifaceId, subnetId string,
) {
c.Assert(ipAddr, gc.NotNil)
c.Assert(ipAddr.MachineId(), gc.Equals, machineId)
c.Assert(ipAddr.InterfaceId(), gc.Equals, ifaceId)
c.Assert(ipAddr.SubnetId(), gc.Equals, subnetId)
c.Assert(ipAddr.Value(), gc.Equals, addr.Value)
c.Assert(ipAddr.Type(), gc.Equals, addr.Type)
c.Assert(ipAddr.Scope(), gc.Equals, addr.Scope)
c.Assert(ipAddr.State(), gc.Equals, ipState)
c.Assert(ipAddr.Address(), jc.DeepEquals, addr)
c.Assert(ipAddr.String(), gc.Equals, addr.String())
c.Assert(ipAddr.Id(), gc.Equals, s.State.EnvironUUID()+":"+addr.Value)
c.Assert(ipAddr.InstanceId(), gc.Equals, instance.UnknownId)
}
