import logging
import time
import itertools
-from functools import wraps
from ganeti import errors
from ganeti import locking
return all_reserved
def GetECReserved(self, ec_id):
+ """ Used when you want to retrieve all reservations for a specific
+ execution context. E.g when commiting reserved IPs for a specific
+ network.
+
+ """
ec_reserved = set()
if ec_id in self._ec_reserved:
ec_reserved.update(self._ec_reserved[ec_id])
return ec_reserved
-
def Generate(self, existing, generate_one_fn, ec_id):
"""Generate a new resource of this type
"""
return os.path.exists(pathutils.CLUSTER_CONF_FILE)
- def _GenerateMACPrefix(self, net=None):
- def _get_mac_prefix(view_func):
- def _decorator(*args, **kwargs):
- prefix = self._config_data.cluster.mac_prefix
- if net:
- net_uuid = self._UnlockedLookupNetwork(net)
- if net_uuid:
- nobj = self._UnlockedGetNetwork(net_uuid)
- if nobj.mac_prefix:
- prefix = nobj.mac_prefix
- suffix = view_func(*args, **kwargs)
- return prefix+':'+suffix
- return wraps(view_func)(_decorator)
- return _get_mac_prefix
-
- def _GenerateMACSuffix(self):
- """Generate one mac address
-
- """
- byte1 = random.randrange(0, 256)
- byte2 = random.randrange(0, 256)
- byte3 = random.randrange(0, 256)
- suffix = "%02x:%02x:%02x" % (byte1, byte2, byte3)
- return suffix
-
@locking.ssynchronized(_config_lock, shared=1)
def GetNdParams(self, node):
"""Get the node params populated with cluster defaults.
"""
return self._config_data.cluster.SimpleFillDP(group.diskparams)
+ def _UnlockedGetNetworkMACPrefix(self, net):
+ """Return the network mac prefix if it exists or the cluster level default.
+
+ """
+ prefix = None
+ if net:
+ net_uuid = self._UnlockedLookupNetwork(net)
+ if net_uuid:
+ nobj = self._UnlockedGetNetwork(net_uuid)
+ if nobj.mac_prefix:
+ prefix = nobj.mac_prefix
+
+ return prefix
+
+ def _GenerateOneMAC(self, prefix=None):
+ """Return a function that randomly generates a MAC suffic
+ and appends it to the given prefix. If prefix is not given get
+ the cluster level default.
+
+ """
+ if not prefix:
+ prefix = self._config_data.cluster.mac_prefix
+
+ def GenMac():
+ byte1 = random.randrange(0, 256)
+ byte2 = random.randrange(0, 256)
+ byte3 = random.randrange(0, 256)
+ mac = "%s:%02x:%02x:%02x" % (prefix, byte1, byte2, byte3)
+ return mac
+
+ return GenMac
+
@locking.ssynchronized(_config_lock, shared=1)
def GenerateMAC(self, net, ec_id):
"""Generate a MAC for an instance.
"""
existing = self._AllMACs()
- gen_mac = self._GenerateMACPrefix(net)(self._GenerateMACSuffix)
+ prefix = self._UnlockedGetNetworkMACPrefix(net)
+ gen_mac = self._GenerateOneMAC(prefix)
return self._temporary_ids.Generate(existing, gen_mac, ec_id)
@locking.ssynchronized(_config_lock, shared=1)
"""
nobj = self._UnlockedGetNetwork(net_uuid)
pool = network.AddressPool(nobj)
- if action == 'reserve':
+ if action == constants.RESERVE_ACTION:
pool.Reserve(address)
- elif action == 'release':
+ elif action == constants.RELEASE_ACTION:
pool.Release(address)
def _UnlockedReleaseIp(self, net_uuid, address, ec_id):
as reserved.
"""
- nobj = self._UnlockedGetNetwork(net_uuid)
- pool = network.AddressPool(nobj)
- self._temporary_ips.Reserve(ec_id, ('release', address, net_uuid))
+ self._temporary_ips.Reserve(ec_id,
+ (constants.RELEASE_ACTION, address, net_uuid))
@locking.ssynchronized(_config_lock, shared=1)
- def ReleaseIp(self, network, address, ec_id):
+ def ReleaseIp(self, net, address, ec_id):
"""Give a specified IP address back to an IP pool.
This is just a wrapper around _UnlockedReleaseIp.
"""
- net_uuid = self._UnlockedLookupNetwork(network)
+ net_uuid = self._UnlockedLookupNetwork(net)
if net_uuid:
self._UnlockedReleaseIp(net_uuid, address, ec_id)
ip = gen_free()
except StopIteration:
raise errors.ReservationError("Cannot generate IP. Network is full")
- return ("reserve", ip, net_uuid)
+ return (constants.RESERVE_ACTION, ip, net_uuid)
- _ ,address, _ = self._temporary_ips.Generate([], gen_one, ec_id)
+ _, address, _ = self._temporary_ips.Generate([], gen_one, ec_id)
return address
def _UnlockedReserveIp(self, net_uuid, address, ec_id):
if isreserved:
raise errors.ReservationError("IP address already in use")
- return self._temporary_ips.Reserve(ec_id, ('reserve', address, net_uuid))
-
+ return self._temporary_ips.Reserve(ec_id,
+ (constants.RESERVE_ACTION,
+ address, net_uuid))
@locking.ssynchronized(_config_lock, shared=1)
def ReserveIp(self, net, address, ec_id):
net_uuid = self._UnlockedLookupNetwork(nic.network)
if net_uuid:
# Return all IP addresses to the respective address pools
- self._UnlockedCommitIp('release', net_uuid, nic.ip)
-
+ self._UnlockedCommitIp(constants.RELEASE_ACTION, net_uuid, nic.ip)
del self._config_data.instances[instance_name]
self._config_data.cluster.serial_no += 1
"""Get a list of network names
"""
- names = [network.name
- for network in self._config_data.networks.values()]
+ names = [net.name
+ for net in self._config_data.networks.values()]
return names
def _UnlockedGetNetwork(self, uuid):
"""
return self._UnlockedGetGroupNetParams(net, node)
-
@locking.ssynchronized(_config_lock, shared=1)
def CheckIPInNodeGroup(self, ip, node):
"""Check for conflictig IP.
for net_uuid in nodegroup_info.networks.keys():
net_info = self._UnlockedGetNetwork(net_uuid)
pool = network.AddressPool(net_info)
- if pool._Contains(ip):
+ if pool.Contains(ip):
return (net_info.name, nodegroup_info.networks[net_uuid])
return (None, None)
projects / ganeti-local / blobdiff