return result
-class ConfigWriter:
+class ConfigWriter(object):
"""The interface to the cluster configuration.
@ivar _temporary_lvs: reservation manager for temporary LVs
return lvnames
def _AllDisks(self):
- """Compute the list of all Disks.
+ """Compute the list of all Disks (recursively, including children).
"""
+ def DiskAndAllChildren(disk):
+ """Returns a list containing the given disk and all of his children.
+
+ """
+ disks = [disk]
+ if disk.children:
+ for child_disk in disk.children:
+ disks.extend(DiskAndAllChildren(child_disk))
+ return disks
+
disks = []
for instance in self._config_data.instances.values():
- disks.extend(instance.disks)
+ for disk in instance.disks:
+ disks.extend(DiskAndAllChildren(disk))
return disks
def _AllNICs(self):
return result
- def _CheckDiskIDs(self, disk, l_ids, p_ids):
+ def _CheckDiskIDs(self, disk, l_ids):
"""Compute duplicate disk IDs
@type disk: L{objects.Disk}
@param disk: the disk at which to start searching
@type l_ids: list
@param l_ids: list of current logical ids
- @type p_ids: list
- @param p_ids: list of current physical ids
@rtype: list
@return: a list of error messages
result.append("duplicate logical id %s" % str(disk.logical_id))
else:
l_ids.append(disk.logical_id)
- if disk.physical_id is not None:
- if disk.physical_id in p_ids:
- result.append("duplicate physical id %s" % str(disk.physical_id))
- else:
- p_ids.append(disk.physical_id)
if disk.children:
for child in disk.children:
- result.extend(self._CheckDiskIDs(child, l_ids, p_ids))
+ result.extend(self._CheckDiskIDs(child, l_ids))
return result
def _UnlockedVerifyConfig(self):
data = self._config_data
cluster = data.cluster
seen_lids = []
- seen_pids = []
# global cluster checks
if not cluster.enabled_hypervisors:
result.append("%s has invalid instance policy: %s" % (owner, err))
for key, value in ipolicy.items():
if key == constants.ISPECS_MINMAX:
- _helper_ispecs(owner, "ipolicy/" + key, value)
+ for k in range(len(value)):
+ _helper_ispecs(owner, "ipolicy/%s[%s]" % (key, k), value[k])
elif key == constants.ISPECS_STD:
_helper(owner, "ipolicy/" + key, value,
constants.ISPECS_PARAMETER_TYPES)
constants.NDS_PARAMETER_TYPES)
_helper_ipolicy("cluster", cluster.ipolicy, True)
+ if constants.DT_RBD in cluster.diskparams:
+ access = cluster.diskparams[constants.DT_RBD][constants.RBD_ACCESS]
+ if access not in constants.DISK_VALID_ACCESS_MODES:
+ result.append(
+ "Invalid value of '%s:%s': '%s' (expected one of %s)" % (
+ constants.DT_RBD, constants.RBD_ACCESS, access,
+ utils.CommaJoin(constants.DISK_VALID_ACCESS_MODES)
+ )
+ )
+
# per-instance checks
- for instance_name in data.instances:
- instance = data.instances[instance_name]
- if instance.name != instance_name:
- result.append("instance '%s' is indexed by wrong name '%s'" %
- (instance.name, instance_name))
+ for instance_uuid in data.instances:
+ instance = data.instances[instance_uuid]
+ if instance.uuid != instance_uuid:
+ result.append("instance '%s' is indexed by wrong UUID '%s'" %
+ (instance.name, instance_uuid))
if instance.primary_node not in data.nodes:
result.append("instance '%s' has invalid primary node '%s'" %
- (instance_name, instance.primary_node))
+ (instance.name, instance.primary_node))
for snode in instance.secondary_nodes:
if snode not in data.nodes:
result.append("instance '%s' has invalid secondary node '%s'" %
- (instance_name, snode))
+ (instance.name, snode))
for idx, nic in enumerate(instance.nics):
if nic.mac in seen_macs:
result.append("instance '%s' has NIC %d mac %s duplicate" %
- (instance_name, idx, nic.mac))
+ (instance.name, idx, nic.mac))
else:
seen_macs.append(nic.mac)
if nic.nicparams:
# disk template checks
if not instance.disk_template in data.cluster.enabled_disk_templates:
result.append("instance '%s' uses the disabled disk template '%s'." %
- (instance_name, instance.disk_template))
+ (instance.name, instance.disk_template))
# parameter checks
if instance.beparams:
# gather the drbd ports for duplicate checks
for (idx, dsk) in enumerate(instance.disks):
- if dsk.dev_type in constants.LDS_DRBD:
+ if dsk.dev_type in constants.DTS_DRBD:
tcp_port = dsk.logical_id[2]
if tcp_port not in ports:
ports[tcp_port] = []
for idx, disk in enumerate(instance.disks):
result.extend(["instance '%s' disk %d error: %s" %
(instance.name, idx, msg) for msg in disk.Verify()])
- result.extend(self._CheckDiskIDs(disk, seen_lids, seen_pids))
+ result.extend(self._CheckDiskIDs(disk, seen_lids))
wrong_names = _CheckInstanceDiskIvNames(instance.disks)
if wrong_names:
(mc_now, mc_max))
# node checks
- for node_name, node in data.nodes.items():
- if node.name != node_name:
- result.append("Node '%s' is indexed by wrong name '%s'" %
- (node.name, node_name))
+ for node_uuid, node in data.nodes.items():
+ if node.uuid != node_uuid:
+ result.append("Node '%s' is indexed by wrong UUID '%s'" %
+ (node.name, node_uuid))
if [node.master_candidate, node.drained, node.offline].count(True) > 1:
result.append("Node %s state is invalid: master_candidate=%s,"
" drain=%s, offline=%s" %
"""
return self._UnlockedVerifyConfig()
- def _UnlockedSetDiskID(self, disk, node_name):
- """Convert the unique ID to the ID needed on the target nodes.
-
- This is used only for drbd, which needs ip/port configuration.
-
- The routine descends down and updates its children also, because
- this helps when the only the top device is passed to the remote
- node.
-
- This function is for internal use, when the config lock is already held.
-
- """
- if disk.children:
- for child in disk.children:
- self._UnlockedSetDiskID(child, node_name)
-
- if disk.logical_id is None and disk.physical_id is not None:
- return
- if disk.dev_type == constants.LD_DRBD8:
- pnode, snode, port, pminor, sminor, secret = disk.logical_id
- if node_name not in (pnode, snode):
- raise errors.ConfigurationError("DRBD device not knowing node %s" %
- node_name)
- pnode_info = self._UnlockedGetNodeInfo(pnode)
- snode_info = self._UnlockedGetNodeInfo(snode)
- if pnode_info is None or snode_info is None:
- raise errors.ConfigurationError("Can't find primary or secondary node"
- " for %s" % str(disk))
- p_data = (pnode_info.secondary_ip, port)
- s_data = (snode_info.secondary_ip, port)
- if pnode == node_name:
- disk.physical_id = p_data + s_data + (pminor, secret)
- else: # it must be secondary, we tested above
- disk.physical_id = s_data + p_data + (sminor, secret)
- else:
- disk.physical_id = disk.logical_id
- return
-
- @locking.ssynchronized(_config_lock)
- def SetDiskID(self, disk, node_name):
- """Convert the unique ID to the ID needed on the target nodes.
-
- This is used only for drbd, which needs ip/port configuration.
-
- The routine descends down and updates its children also, because
- this helps when the only the top device is passed to the remote
- node.
-
- """
- return self._UnlockedSetDiskID(disk, node_name)
-
@locking.ssynchronized(_config_lock)
def AddTcpUdpPort(self, port):
"""Adds a new port to the available port pool.
"""Compute the used DRBD minor/nodes.
@rtype: (dict, list)
- @return: dictionary of node_name: dict of minor: instance_name;
+ @return: dictionary of node_uuid: dict of minor: instance_uuid;
the returned dict will have all the nodes in it (even if with
an empty list), and a list of duplicates; if the duplicates
list is not empty, the configuration is corrupted and its caller
should raise an exception
"""
- def _AppendUsedPorts(instance_name, disk, used):
+ def _AppendUsedMinors(get_node_name_fn, instance, disk, used):
duplicates = []
- if disk.dev_type == constants.LD_DRBD8 and len(disk.logical_id) >= 5:
+ if disk.dev_type == constants.DT_DRBD8 and len(disk.logical_id) >= 5:
node_a, node_b, _, minor_a, minor_b = disk.logical_id[:5]
- for node, port in ((node_a, minor_a), (node_b, minor_b)):
- assert node in used, ("Node '%s' of instance '%s' not found"
- " in node list" % (node, instance_name))
- if port in used[node]:
- duplicates.append((node, port, instance_name, used[node][port]))
+ for node_uuid, minor in ((node_a, minor_a), (node_b, minor_b)):
+ assert node_uuid in used, \
+ ("Node '%s' of instance '%s' not found in node list" %
+ (get_node_name_fn(node_uuid), instance.name))
+ if minor in used[node_uuid]:
+ duplicates.append((node_uuid, minor, instance.uuid,
+ used[node_uuid][minor]))
else:
- used[node][port] = instance_name
+ used[node_uuid][minor] = instance.uuid
if disk.children:
for child in disk.children:
- duplicates.extend(_AppendUsedPorts(instance_name, child, used))
+ duplicates.extend(_AppendUsedMinors(get_node_name_fn, instance, child,
+ used))
return duplicates
duplicates = []
- my_dict = dict((node, {}) for node in self._config_data.nodes)
+ my_dict = dict((node_uuid, {}) for node_uuid in self._config_data.nodes)
for instance in self._config_data.instances.itervalues():
for disk in instance.disks:
- duplicates.extend(_AppendUsedPorts(instance.name, disk, my_dict))
- for (node, minor), instance in self._temporary_drbds.iteritems():
- if minor in my_dict[node] and my_dict[node][minor] != instance:
- duplicates.append((node, minor, instance, my_dict[node][minor]))
+ duplicates.extend(_AppendUsedMinors(self._UnlockedGetNodeName,
+ instance, disk, my_dict))
+ for (node_uuid, minor), inst_uuid in self._temporary_drbds.iteritems():
+ if minor in my_dict[node_uuid] and my_dict[node_uuid][minor] != inst_uuid:
+ duplicates.append((node_uuid, minor, inst_uuid,
+ my_dict[node_uuid][minor]))
else:
- my_dict[node][minor] = instance
+ my_dict[node_uuid][minor] = inst_uuid
return my_dict, duplicates
@locking.ssynchronized(_config_lock)
This is just a wrapper over L{_UnlockedComputeDRBDMap}.
- @return: dictionary of node_name: dict of minor: instance_name;
+ @return: dictionary of node_uuid: dict of minor: instance_uuid;
the returned dict will have all the nodes in it (even if with
an empty list).
return d_map
@locking.ssynchronized(_config_lock)
- def AllocateDRBDMinor(self, nodes, instance):
+ def AllocateDRBDMinor(self, node_uuids, inst_uuid):
"""Allocate a drbd minor.
The free minor will be automatically computed from the existing
multiple minors. The result is the list of minors, in the same
order as the passed nodes.
- @type instance: string
- @param instance: the instance for which we allocate minors
+ @type inst_uuid: string
+ @param inst_uuid: the instance for which we allocate minors
"""
- assert isinstance(instance, basestring), \
- "Invalid argument '%s' passed to AllocateDRBDMinor" % instance
+ assert isinstance(inst_uuid, basestring), \
+ "Invalid argument '%s' passed to AllocateDRBDMinor" % inst_uuid
d_map, duplicates = self._UnlockedComputeDRBDMap()
if duplicates:
raise errors.ConfigurationError("Duplicate DRBD ports detected: %s" %
str(duplicates))
result = []
- for nname in nodes:
- ndata = d_map[nname]
+ for nuuid in node_uuids:
+ ndata = d_map[nuuid]
if not ndata:
# no minors used, we can start at 0
result.append(0)
- ndata[0] = instance
- self._temporary_drbds[(nname, 0)] = instance
+ ndata[0] = inst_uuid
+ self._temporary_drbds[(nuuid, 0)] = inst_uuid
continue
keys = ndata.keys()
keys.sort()
else:
minor = ffree
# double-check minor against current instances
- assert minor not in d_map[nname], \
+ assert minor not in d_map[nuuid], \
("Attempt to reuse allocated DRBD minor %d on node %s,"
" already allocated to instance %s" %
- (minor, nname, d_map[nname][minor]))
- ndata[minor] = instance
+ (minor, nuuid, d_map[nuuid][minor]))
+ ndata[minor] = inst_uuid
# double-check minor against reservation
- r_key = (nname, minor)
+ r_key = (nuuid, minor)
assert r_key not in self._temporary_drbds, \
("Attempt to reuse reserved DRBD minor %d on node %s,"
" reserved for instance %s" %
- (minor, nname, self._temporary_drbds[r_key]))
- self._temporary_drbds[r_key] = instance
+ (minor, nuuid, self._temporary_drbds[r_key]))
+ self._temporary_drbds[r_key] = inst_uuid
result.append(minor)
logging.debug("Request to allocate drbd minors, input: %s, returning %s",
- nodes, result)
+ node_uuids, result)
return result
- def _UnlockedReleaseDRBDMinors(self, instance):
+ def _UnlockedReleaseDRBDMinors(self, inst_uuid):
"""Release temporary drbd minors allocated for a given instance.
- @type instance: string
- @param instance: the instance for which temporary minors should be
- released
+ @type inst_uuid: string
+ @param inst_uuid: the instance for which temporary minors should be
+ released
"""
- assert isinstance(instance, basestring), \
+ assert isinstance(inst_uuid, basestring), \
"Invalid argument passed to ReleaseDRBDMinors"
- for key, name in self._temporary_drbds.items():
- if name == instance:
+ for key, uuid in self._temporary_drbds.items():
+ if uuid == inst_uuid:
del self._temporary_drbds[key]
@locking.ssynchronized(_config_lock)
- def ReleaseDRBDMinors(self, instance):
+ def ReleaseDRBDMinors(self, inst_uuid):
"""Release temporary drbd minors allocated for a given instance.
This should be called on the error paths, on the success paths
This function is just a wrapper over L{_UnlockedReleaseDRBDMinors}.
- @type instance: string
- @param instance: the instance for which temporary minors should be
- released
+ @type inst_uuid: string
+ @param inst_uuid: the instance for which temporary minors should be
+ released
"""
- self._UnlockedReleaseDRBDMinors(instance)
+ self._UnlockedReleaseDRBDMinors(inst_uuid)
@locking.ssynchronized(_config_lock, shared=1)
def GetConfigVersion(self):
@locking.ssynchronized(_config_lock, shared=1)
def GetMasterNode(self):
- """Get the hostname of the master node for this cluster.
+ """Get the UUID of the master node for this cluster.
- @return: Master hostname
+ @return: Master node UUID
"""
return self._config_data.cluster.master_node
@locking.ssynchronized(_config_lock, shared=1)
+ def GetMasterNodeName(self):
+ """Get the hostname of the master node for this cluster.
+
+ @return: Master node hostname
+
+ """
+ return self._UnlockedGetNodeName(self._config_data.cluster.master_node)
+
+ @locking.ssynchronized(_config_lock, shared=1)
+ def GetMasterNodeInfo(self):
+ """Get the master node information for this cluster.
+
+ @rtype: objects.Node
+ @return: Master node L{objects.Node} object
+
+ """
+ return self._UnlockedGetNodeInfo(self._config_data.cluster.master_node)
+
+ @locking.ssynchronized(_config_lock, shared=1)
def GetMasterIP(self):
"""Get the IP of the master node for this cluster.
return self._config_data.cluster.enabled_hypervisors[0]
@locking.ssynchronized(_config_lock, shared=1)
- def GetHostKey(self):
+ def GetRsaHostKey(self):
"""Return the rsa hostkey from the config.
@rtype: string
return self._config_data.cluster.rsahostkeypub
@locking.ssynchronized(_config_lock, shared=1)
+ def GetDsaHostKey(self):
+ """Return the dsa hostkey from the config.
+
+ @rtype: string
+ @return: the dsa hostkey
+
+ """
+ return self._config_data.cluster.dsahostkeypub
+
+ @locking.ssynchronized(_config_lock, shared=1)
def GetDefaultIAllocator(self):
"""Get the default instance allocator for this cluster.
"""
cluster = self._config_data.cluster
result = objects.MasterNetworkParameters(
- name=cluster.master_node, ip=cluster.master_ip,
+ uuid=cluster.master_node, ip=cluster.master_ip,
netmask=cluster.master_netmask, netdev=cluster.master_netdev,
ip_family=cluster.primary_ip_family)
"""Get nodes which are member in the same nodegroups as the given nodes.
"""
- ngfn = lambda node_name: self._UnlockedGetNodeInfo(node_name).group
- return frozenset(member_name
- for node_name in nodes
- for member_name in
- self._UnlockedGetNodeGroup(ngfn(node_name)).members)
+ ngfn = lambda node_uuid: self._UnlockedGetNodeInfo(node_uuid).group
+ return frozenset(member_uuid
+ for node_uuid in nodes
+ for member_uuid in
+ self._UnlockedGetNodeGroup(ngfn(node_uuid)).members)
@locking.ssynchronized(_config_lock, shared=1)
def GetMultiNodeGroupInfo(self, group_uuids):
" MAC address '%s' already in use." %
(instance.name, nic.mac))
- self._EnsureUUID(instance, ec_id)
+ self._CheckUniqueUUID(instance, include_temporary=False)
instance.serial_no = 1
instance.ctime = instance.mtime = time.time()
- self._config_data.instances[instance.name] = instance
+ self._config_data.instances[instance.uuid] = instance
self._config_data.cluster.serial_no += 1
- self._UnlockedReleaseDRBDMinors(instance.name)
+ self._UnlockedReleaseDRBDMinors(instance.uuid)
self._UnlockedCommitTemporaryIps(ec_id)
self._WriteConfig()
"""
if not item.uuid:
item.uuid = self._GenerateUniqueID(ec_id)
- elif item.uuid in self._AllIDs(include_temporary=True):
+ else:
+ self._CheckUniqueUUID(item, include_temporary=True)
+
+ def _CheckUniqueUUID(self, item, include_temporary):
+ """Checks that the UUID of the given object is unique.
+
+ @param item: the instance or node to be checked
+ @param include_temporary: whether temporarily generated UUID's should be
+ included in the check. If the UUID of the item to be checked is
+ a temporarily generated one, this has to be C{False}.
+
+ """
+ if not item.uuid:
+ raise errors.ConfigurationError("'%s' must have an UUID" % (item.name,))
+ if item.uuid in self._AllIDs(include_temporary=include_temporary):
raise errors.ConfigurationError("Cannot add '%s': UUID %s already"
" in use" % (item.name, item.uuid))
- def _SetInstanceStatus(self, instance_name, status):
+ def _SetInstanceStatus(self, inst_uuid, status, disks_active):
"""Set the instance's status to a given value.
"""
+ if inst_uuid not in self._config_data.instances:
+ raise errors.ConfigurationError("Unknown instance '%s'" %
+ inst_uuid)
+ instance = self._config_data.instances[inst_uuid]
+
+ if status is None:
+ status = instance.admin_state
+ if disks_active is None:
+ disks_active = instance.disks_active
+
assert status in constants.ADMINST_ALL, \
"Invalid status '%s' passed to SetInstanceStatus" % (status,)
- if instance_name not in self._config_data.instances:
- raise errors.ConfigurationError("Unknown instance '%s'" %
- instance_name)
- instance = self._config_data.instances[instance_name]
- if instance.admin_state != status:
+ if instance.admin_state != status or \
+ instance.disks_active != disks_active:
instance.admin_state = status
+ instance.disks_active = disks_active
instance.serial_no += 1
instance.mtime = time.time()
self._WriteConfig()
@locking.ssynchronized(_config_lock)
- def MarkInstanceUp(self, instance_name):
+ def MarkInstanceUp(self, inst_uuid):
"""Mark the instance status to up in the config.
+ This also sets the instance disks active flag.
+
"""
- self._SetInstanceStatus(instance_name, constants.ADMINST_UP)
+ self._SetInstanceStatus(inst_uuid, constants.ADMINST_UP, True)
@locking.ssynchronized(_config_lock)
- def MarkInstanceOffline(self, instance_name):
+ def MarkInstanceOffline(self, inst_uuid):
"""Mark the instance status to down in the config.
+ This also clears the instance disks active flag.
+
"""
- self._SetInstanceStatus(instance_name, constants.ADMINST_OFFLINE)
+ self._SetInstanceStatus(inst_uuid, constants.ADMINST_OFFLINE, False)
@locking.ssynchronized(_config_lock)
- def RemoveInstance(self, instance_name):
+ def RemoveInstance(self, inst_uuid):
"""Remove the instance from the configuration.
"""
- if instance_name not in self._config_data.instances:
- raise errors.ConfigurationError("Unknown instance '%s'" % instance_name)
+ if inst_uuid not in self._config_data.instances:
+ raise errors.ConfigurationError("Unknown instance '%s'" % inst_uuid)
# If a network port has been allocated to the instance,
# return it to the pool of free ports.
- inst = self._config_data.instances[instance_name]
+ inst = self._config_data.instances[inst_uuid]
network_port = getattr(inst, "network_port", None)
if network_port is not None:
self._config_data.cluster.tcpudp_port_pool.add(network_port)
- instance = self._UnlockedGetInstanceInfo(instance_name)
+ instance = self._UnlockedGetInstanceInfo(inst_uuid)
for nic in instance.nics:
if nic.network and nic.ip:
# Return all IP addresses to the respective address pools
self._UnlockedCommitIp(constants.RELEASE_ACTION, nic.network, nic.ip)
- del self._config_data.instances[instance_name]
+ del self._config_data.instances[inst_uuid]
self._config_data.cluster.serial_no += 1
self._WriteConfig()
@locking.ssynchronized(_config_lock)
- def RenameInstance(self, old_name, new_name):
+ def RenameInstance(self, inst_uuid, new_name):
"""Rename an instance.
This needs to be done in ConfigWriter and not by RemoveInstance
rename.
"""
- if old_name not in self._config_data.instances:
- raise errors.ConfigurationError("Unknown instance '%s'" % old_name)
+ if inst_uuid not in self._config_data.instances:
+ raise errors.ConfigurationError("Unknown instance '%s'" % inst_uuid)
- # Operate on a copy to not loose instance object in case of a failure
- inst = self._config_data.instances[old_name].Copy()
+ inst = self._config_data.instances[inst_uuid]
inst.name = new_name
for (idx, disk) in enumerate(inst.disks):
- if disk.dev_type == constants.LD_FILE:
+ if disk.dev_type in [constants.DT_FILE, constants.DT_SHARED_FILE]:
# rename the file paths in logical and physical id
file_storage_dir = os.path.dirname(os.path.dirname(disk.logical_id[1]))
disk.logical_id = (disk.logical_id[0],
utils.PathJoin(file_storage_dir, inst.name,
"disk%s" % idx))
- disk.physical_id = disk.logical_id
-
- # Actually replace instance object
- del self._config_data.instances[old_name]
- self._config_data.instances[inst.name] = inst
# Force update of ssconf files
self._config_data.cluster.serial_no += 1
self._WriteConfig()
@locking.ssynchronized(_config_lock)
- def MarkInstanceDown(self, instance_name):
+ def MarkInstanceDown(self, inst_uuid):
"""Mark the status of an instance to down in the configuration.
+ This does not touch the instance disks active flag, as shut down instances
+ can still have active disks.
+
"""
- self._SetInstanceStatus(instance_name, constants.ADMINST_DOWN)
+ self._SetInstanceStatus(inst_uuid, constants.ADMINST_DOWN, None)
+
+ @locking.ssynchronized(_config_lock)
+ def MarkInstanceDisksActive(self, inst_uuid):
+ """Mark the status of instance disks active.
+
+ """
+ self._SetInstanceStatus(inst_uuid, None, True)
+
+ @locking.ssynchronized(_config_lock)
+ def MarkInstanceDisksInactive(self, inst_uuid):
+ """Mark the status of instance disks inactive.
+
+ """
+ self._SetInstanceStatus(inst_uuid, None, False)
def _UnlockedGetInstanceList(self):
"""Get the list of instances.
def GetInstanceList(self):
"""Get the list of instances.
- @return: array of instances, ex. ['instance2.example.com',
- 'instance1.example.com']
+ @return: array of instances, ex. ['instance2-uuid', 'instance1-uuid']
"""
return self._UnlockedGetInstanceList()
"""Attempt to expand an incomplete instance name.
"""
- # Locking is done in L{ConfigWriter.GetInstanceList}
- return _MatchNameComponentIgnoreCase(short_name, self.GetInstanceList())
+ # Locking is done in L{ConfigWriter.GetAllInstancesInfo}
+ all_insts = self.GetAllInstancesInfo().values()
+ expanded_name = _MatchNameComponentIgnoreCase(
+ short_name, [inst.name for inst in all_insts])
+
+ if expanded_name is not None:
+ # there has to be exactly one instance with that name
+ inst = (filter(lambda n: n.name == expanded_name, all_insts)[0])
+ return (inst.uuid, inst.name)
+ else:
+ return (None, None)
- def _UnlockedGetInstanceInfo(self, instance_name):
+ def _UnlockedGetInstanceInfo(self, inst_uuid):
"""Returns information about an instance.
This function is for internal use, when the config lock is already held.
"""
- if instance_name not in self._config_data.instances:
+ if inst_uuid not in self._config_data.instances:
return None
- return self._config_data.instances[instance_name]
+ return self._config_data.instances[inst_uuid]
@locking.ssynchronized(_config_lock, shared=1)
- def GetInstanceInfo(self, instance_name):
+ def GetInstanceInfo(self, inst_uuid):
"""Returns information about an instance.
It takes the information from the configuration file. Other information of
an instance are taken from the live systems.
- @param instance_name: name of the instance, e.g.
- I{instance1.example.com}
+ @param inst_uuid: UUID of the instance
@rtype: L{objects.Instance}
@return: the instance object
"""
- return self._UnlockedGetInstanceInfo(instance_name)
+ return self._UnlockedGetInstanceInfo(inst_uuid)
@locking.ssynchronized(_config_lock, shared=1)
- def GetInstanceNodeGroups(self, instance_name, primary_only=False):
+ def GetInstanceNodeGroups(self, inst_uuid, primary_only=False):
"""Returns set of node group UUIDs for instance's nodes.
@rtype: frozenset
"""
- instance = self._UnlockedGetInstanceInfo(instance_name)
+ instance = self._UnlockedGetInstanceInfo(inst_uuid)
if not instance:
- raise errors.ConfigurationError("Unknown instance '%s'" % instance_name)
+ raise errors.ConfigurationError("Unknown instance '%s'" % inst_uuid)
if primary_only:
nodes = [instance.primary_node]
else:
nodes = instance.all_nodes
- return frozenset(self._UnlockedGetNodeInfo(node_name).group
- for node_name in nodes)
+ return frozenset(self._UnlockedGetNodeInfo(node_uuid).group
+ for node_uuid in nodes)
@locking.ssynchronized(_config_lock, shared=1)
- def GetInstanceNetworks(self, instance_name):
+ def GetInstanceNetworks(self, inst_uuid):
"""Returns set of network UUIDs for instance's nics.
@rtype: frozenset
"""
- instance = self._UnlockedGetInstanceInfo(instance_name)
+ instance = self._UnlockedGetInstanceInfo(inst_uuid)
if not instance:
- raise errors.ConfigurationError("Unknown instance '%s'" % instance_name)
+ raise errors.ConfigurationError("Unknown instance '%s'" % inst_uuid)
networks = set()
for nic in instance.nics:
return frozenset(networks)
@locking.ssynchronized(_config_lock, shared=1)
- def GetMultiInstanceInfo(self, instances):
+ def GetMultiInstanceInfo(self, inst_uuids):
+ """Get the configuration of multiple instances.
+
+ @param inst_uuids: list of instance UUIDs
+ @rtype: list
+ @return: list of tuples (instance UUID, instance_info), where
+ instance_info is what would GetInstanceInfo return for the
+ node, while keeping the original order
+
+ """
+ return [(uuid, self._UnlockedGetInstanceInfo(uuid)) for uuid in inst_uuids]
+
+ @locking.ssynchronized(_config_lock, shared=1)
+ def GetMultiInstanceInfoByName(self, inst_names):
"""Get the configuration of multiple instances.
- @param instances: list of instance names
+ @param inst_names: list of instance names
@rtype: list
@return: list of tuples (instance, instance_info), where
instance_info is what would GetInstanceInfo return for the
node, while keeping the original order
"""
- return [(name, self._UnlockedGetInstanceInfo(name)) for name in instances]
+ result = []
+ for name in inst_names:
+ instance = self._UnlockedGetInstanceInfoByName(name)
+ result.append((instance.uuid, instance))
+ return result
@locking.ssynchronized(_config_lock, shared=1)
def GetAllInstancesInfo(self):
would GetInstanceInfo return for the node
"""
- my_dict = dict([(instance, self._UnlockedGetInstanceInfo(instance))
- for instance in self._UnlockedGetInstanceList()])
+ return self._UnlockedGetAllInstancesInfo()
+
+ def _UnlockedGetAllInstancesInfo(self):
+ my_dict = dict([(inst_uuid, self._UnlockedGetInstanceInfo(inst_uuid))
+ for inst_uuid in self._UnlockedGetInstanceList()])
return my_dict
@locking.ssynchronized(_config_lock, shared=1)
other functions and just compares instance attributes.
"""
- return dict((name, inst)
- for (name, inst) in self._config_data.instances.items()
+ return dict((uuid, inst)
+ for (uuid, inst) in self._config_data.instances.items()
if filter_fn(inst))
+ @locking.ssynchronized(_config_lock, shared=1)
+ def GetInstanceInfoByName(self, inst_name):
+ """Get the L{objects.Instance} object for a named instance.
+
+ @param inst_name: name of the instance to get information for
+ @type inst_name: string
+ @return: the corresponding L{objects.Instance} instance or None if no
+ information is available
+
+ """
+ return self._UnlockedGetInstanceInfoByName(inst_name)
+
+ def _UnlockedGetInstanceInfoByName(self, inst_name):
+ for inst in self._UnlockedGetAllInstancesInfo().values():
+ if inst.name == inst_name:
+ return inst
+ return None
+
+ def _UnlockedGetInstanceName(self, inst_uuid):
+ inst_info = self._UnlockedGetInstanceInfo(inst_uuid)
+ if inst_info is None:
+ raise errors.OpExecError("Unknown instance: %s" % inst_uuid)
+ return inst_info.name
+
+ @locking.ssynchronized(_config_lock, shared=1)
+ def GetInstanceName(self, inst_uuid):
+ """Gets the instance name for the passed instance.
+
+ @param inst_uuid: instance UUID to get name for
+ @type inst_uuid: string
+ @rtype: string
+ @return: instance name
+
+ """
+ return self._UnlockedGetInstanceName(inst_uuid)
+
+ @locking.ssynchronized(_config_lock, shared=1)
+ def GetInstanceNames(self, inst_uuids):
+ """Gets the instance names for the passed list of nodes.
+
+ @param inst_uuids: list of instance UUIDs to get names for
+ @type inst_uuids: list of strings
+ @rtype: list of strings
+ @return: list of instance names
+
+ """
+ return self._UnlockedGetInstanceNames(inst_uuids)
+
+ def _UnlockedGetInstanceNames(self, inst_uuids):
+ return [self._UnlockedGetInstanceName(uuid) for uuid in inst_uuids]
+
@locking.ssynchronized(_config_lock)
def AddNode(self, node, ec_id):
"""Add a node to the configuration.
node.serial_no = 1
node.ctime = node.mtime = time.time()
- self._UnlockedAddNodeToGroup(node.name, node.group)
- self._config_data.nodes[node.name] = node
+ self._UnlockedAddNodeToGroup(node.uuid, node.group)
+ self._config_data.nodes[node.uuid] = node
self._config_data.cluster.serial_no += 1
self._WriteConfig()
@locking.ssynchronized(_config_lock)
- def RemoveNode(self, node_name):
+ def RemoveNode(self, node_uuid):
"""Remove a node from the configuration.
"""
- logging.info("Removing node %s from configuration", node_name)
+ logging.info("Removing node %s from configuration", node_uuid)
- if node_name not in self._config_data.nodes:
- raise errors.ConfigurationError("Unknown node '%s'" % node_name)
+ if node_uuid not in self._config_data.nodes:
+ raise errors.ConfigurationError("Unknown node '%s'" % node_uuid)
- self._UnlockedRemoveNodeFromGroup(self._config_data.nodes[node_name])
- del self._config_data.nodes[node_name]
+ self._UnlockedRemoveNodeFromGroup(self._config_data.nodes[node_uuid])
+ del self._config_data.nodes[node_uuid]
self._config_data.cluster.serial_no += 1
self._WriteConfig()
def ExpandNodeName(self, short_name):
- """Attempt to expand an incomplete node name.
+ """Attempt to expand an incomplete node name into a node UUID.
"""
- # Locking is done in L{ConfigWriter.GetNodeList}
- return _MatchNameComponentIgnoreCase(short_name, self.GetNodeList())
+ # Locking is done in L{ConfigWriter.GetAllNodesInfo}
+ all_nodes = self.GetAllNodesInfo().values()
+ expanded_name = _MatchNameComponentIgnoreCase(
+ short_name, [node.name for node in all_nodes])
- def _UnlockedGetNodeInfo(self, node_name):
+ if expanded_name is not None:
+ # there has to be exactly one node with that name
+ node = (filter(lambda n: n.name == expanded_name, all_nodes)[0])
+ return (node.uuid, node.name)
+ else:
+ return (None, None)
+
+ def _UnlockedGetNodeInfo(self, node_uuid):
"""Get the configuration of a node, as stored in the config.
This function is for internal use, when the config lock is already
held.
- @param node_name: the node name, e.g. I{node1.example.com}
+ @param node_uuid: the node UUID
@rtype: L{objects.Node}
@return: the node object
"""
- if node_name not in self._config_data.nodes:
+ if node_uuid not in self._config_data.nodes:
return None
- return self._config_data.nodes[node_name]
+ return self._config_data.nodes[node_uuid]
@locking.ssynchronized(_config_lock, shared=1)
- def GetNodeInfo(self, node_name):
+ def GetNodeInfo(self, node_uuid):
"""Get the configuration of a node, as stored in the config.
This is just a locked wrapper over L{_UnlockedGetNodeInfo}.
- @param node_name: the node name, e.g. I{node1.example.com}
+ @param node_uuid: the node UUID
@rtype: L{objects.Node}
@return: the node object
"""
- return self._UnlockedGetNodeInfo(node_name)
+ return self._UnlockedGetNodeInfo(node_uuid)
@locking.ssynchronized(_config_lock, shared=1)
- def GetNodeInstances(self, node_name):
+ def GetNodeInstances(self, node_uuid):
"""Get the instances of a node, as stored in the config.
- @param node_name: the node name, e.g. I{node1.example.com}
+ @param node_uuid: the node UUID
@rtype: (list, list)
@return: a tuple with two lists: the primary and the secondary instances
pri = []
sec = []
for inst in self._config_data.instances.values():
- if inst.primary_node == node_name:
- pri.append(inst.name)
- if node_name in inst.secondary_nodes:
- sec.append(inst.name)
+ if inst.primary_node == node_uuid:
+ pri.append(inst.uuid)
+ if node_uuid in inst.secondary_nodes:
+ sec.append(inst.uuid)
return (pri, sec)
@locking.ssynchronized(_config_lock, shared=1)
@param uuid: Node group UUID
@param primary_only: Whether to only consider primary nodes
@rtype: frozenset
- @return: List of instance names in node group
+ @return: List of instance UUIDs in node group
"""
if primary_only:
else:
nodes_fn = lambda inst: inst.all_nodes
- return frozenset(inst.name
+ return frozenset(inst.uuid
for inst in self._config_data.instances.values()
- for node_name in nodes_fn(inst)
- if self._UnlockedGetNodeInfo(node_name).group == uuid)
+ for node_uuid in nodes_fn(inst)
+ if self._UnlockedGetNodeInfo(node_uuid).group == uuid)
+
+ def _UnlockedGetHvparamsString(self, hvname):
+ """Return the string representation of the list of hyervisor parameters of
+ the given hypervisor.
+
+ @see: C{GetHvparams}
+
+ """
+ result = ""
+ hvparams = self._config_data.cluster.hvparams[hvname]
+ for key in hvparams:
+ result += "%s=%s\n" % (key, hvparams[key])
+ return result
+
+ @locking.ssynchronized(_config_lock, shared=1)
+ def GetHvparamsString(self, hvname):
+ """Return the hypervisor parameters of the given hypervisor.
+
+ @type hvname: string
+ @param hvname: name of a hypervisor
+ @rtype: string
+ @return: string containing key-value-pairs, one pair on each line;
+ format: KEY=VALUE
+
+ """
+ return self._UnlockedGetHvparamsString(hvname)
def _UnlockedGetNodeList(self):
"""Return the list of nodes which are in the configuration.
"""
all_nodes = [self._UnlockedGetNodeInfo(node)
for node in self._UnlockedGetNodeList()]
- return [node.name for node in all_nodes if not node.offline]
+ return [node.uuid for node in all_nodes if not node.offline]
@locking.ssynchronized(_config_lock, shared=1)
def GetOnlineNodeList(self):
"""
all_nodes = [self._UnlockedGetNodeInfo(node)
for node in self._UnlockedGetNodeList()]
- return [node.name for node in all_nodes if node.vm_capable]
+ return [node.uuid for node in all_nodes if node.vm_capable]
@locking.ssynchronized(_config_lock, shared=1)
def GetNonVmCapableNodeList(self):
"""
all_nodes = [self._UnlockedGetNodeInfo(node)
for node in self._UnlockedGetNodeList()]
- return [node.name for node in all_nodes if not node.vm_capable]
+ return [node.uuid for node in all_nodes if not node.vm_capable]
@locking.ssynchronized(_config_lock, shared=1)
- def GetMultiNodeInfo(self, nodes):
+ def GetMultiNodeInfo(self, node_uuids):
"""Get the configuration of multiple nodes.
- @param nodes: list of node names
+ @param node_uuids: list of node UUIDs
@rtype: list
@return: list of tuples of (node, node_info), where node_info is
what would GetNodeInfo return for the node, in the original
order
"""
- return [(name, self._UnlockedGetNodeInfo(name)) for name in nodes]
+ return [(uuid, self._UnlockedGetNodeInfo(uuid)) for uuid in node_uuids]
+
+ def _UnlockedGetAllNodesInfo(self):
+ """Gets configuration of all nodes.
+
+ @note: See L{GetAllNodesInfo}
+
+ """
+ return dict([(node_uuid, self._UnlockedGetNodeInfo(node_uuid))
+ for node_uuid in self._UnlockedGetNodeList()])
@locking.ssynchronized(_config_lock, shared=1)
def GetAllNodesInfo(self):
"""
return self._UnlockedGetAllNodesInfo()
- def _UnlockedGetAllNodesInfo(self):
- """Gets configuration of all nodes.
+ def _UnlockedGetNodeInfoByName(self, node_name):
+ for node in self._UnlockedGetAllNodesInfo().values():
+ if node.name == node_name:
+ return node
+ return None
- @note: See L{GetAllNodesInfo}
+ @locking.ssynchronized(_config_lock, shared=1)
+ def GetNodeInfoByName(self, node_name):
+ """Get the L{objects.Node} object for a named node.
+
+ @param node_name: name of the node to get information for
+ @type node_name: string
+ @return: the corresponding L{objects.Node} instance or None if no
+ information is available
"""
- return dict([(node, self._UnlockedGetNodeInfo(node))
- for node in self._UnlockedGetNodeList()])
+ return self._UnlockedGetNodeInfoByName(node_name)
+
+ def _UnlockedGetNodeName(self, node_spec):
+ if isinstance(node_spec, objects.Node):
+ return node_spec.name
+ elif isinstance(node_spec, basestring):
+ node_info = self._UnlockedGetNodeInfo(node_spec)
+ if node_info is None:
+ raise errors.OpExecError("Unknown node: %s" % node_spec)
+ return node_info.name
+ else:
+ raise errors.ProgrammerError("Can't handle node spec '%s'" % node_spec)
@locking.ssynchronized(_config_lock, shared=1)
- def GetNodeGroupsFromNodes(self, nodes):
+ def GetNodeName(self, node_spec):
+ """Gets the node name for the passed node.
+
+ @param node_spec: node to get names for
+ @type node_spec: either node UUID or a L{objects.Node} object
+ @rtype: string
+ @return: node name
+
+ """
+ return self._UnlockedGetNodeName(node_spec)
+
+ def _UnlockedGetNodeNames(self, node_specs):
+ return [self._UnlockedGetNodeName(node_spec) for node_spec in node_specs]
+
+ @locking.ssynchronized(_config_lock, shared=1)
+ def GetNodeNames(self, node_specs):
+ """Gets the node names for the passed list of nodes.
+
+ @param node_specs: list of nodes to get names for
+ @type node_specs: list of either node UUIDs or L{objects.Node} objects
+ @rtype: list of strings
+ @return: list of node names
+
+ """
+ return self._UnlockedGetNodeNames(node_specs)
+
+ @locking.ssynchronized(_config_lock, shared=1)
+ def GetNodeGroupsFromNodes(self, node_uuids):
"""Returns groups for a list of nodes.
- @type nodes: list of string
- @param nodes: List of node names
+ @type node_uuids: list of string
+ @param node_uuids: List of node UUIDs
@rtype: frozenset
"""
- return frozenset(self._UnlockedGetNodeInfo(name).group for name in nodes)
+ return frozenset(self._UnlockedGetNodeInfo(uuid).group
+ for uuid in node_uuids)
def _UnlockedGetMasterCandidateStats(self, exceptions=None):
"""Get the number of current and maximum desired and possible candidates.
"""
mc_now = mc_should = mc_max = 0
for node in self._config_data.nodes.values():
- if exceptions and node.name in exceptions:
+ if exceptions and node.uuid in exceptions:
continue
if not (node.offline or node.drained) and node.master_capable:
mc_max += 1
return self._UnlockedGetMasterCandidateStats(exceptions)
@locking.ssynchronized(_config_lock)
- def MaintainCandidatePool(self, exceptions):
+ def MaintainCandidatePool(self, exception_node_uuids):
"""Try to grow the candidate pool to the desired size.
- @type exceptions: list
- @param exceptions: if passed, list of nodes that should be ignored
+ @type exception_node_uuids: list
+ @param exception_node_uuids: if passed, list of nodes that should be ignored
@rtype: list
@return: list with the adjusted nodes (L{objects.Node} instances)
"""
- mc_now, mc_max, _ = self._UnlockedGetMasterCandidateStats(exceptions)
+ mc_now, mc_max, _ = self._UnlockedGetMasterCandidateStats(
+ exception_node_uuids)
mod_list = []
if mc_now < mc_max:
node_list = self._config_data.nodes.keys()
random.shuffle(node_list)
- for name in node_list:
+ for uuid in node_list:
if mc_now >= mc_max:
break
- node = self._config_data.nodes[name]
+ node = self._config_data.nodes[uuid]
if (node.master_candidate or node.offline or node.drained or
- node.name in exceptions or not node.master_capable):
+ node.uuid in exception_node_uuids or not node.master_capable):
continue
mod_list.append(node)
node.master_candidate = True
return mod_list
- def _UnlockedAddNodeToGroup(self, node_name, nodegroup_uuid):
+ def _UnlockedAddNodeToGroup(self, node_uuid, nodegroup_uuid):
"""Add a given node to the specified group.
"""
# the meantime. It's ok though, as we'll fail cleanly if the node group
# is not found anymore.
raise errors.OpExecError("Unknown node group: %s" % nodegroup_uuid)
- if node_name not in self._config_data.nodegroups[nodegroup_uuid].members:
- self._config_data.nodegroups[nodegroup_uuid].members.append(node_name)
+ if node_uuid not in self._config_data.nodegroups[nodegroup_uuid].members:
+ self._config_data.nodegroups[nodegroup_uuid].members.append(node_uuid)
def _UnlockedRemoveNodeFromGroup(self, node):
"""Remove a given node from its group.
nodegroup = node.group
if nodegroup not in self._config_data.nodegroups:
logging.warning("Warning: node '%s' has unknown node group '%s'"
- " (while being removed from it)", node.name, nodegroup)
+ " (while being removed from it)", node.uuid, nodegroup)
nodegroup_obj = self._config_data.nodegroups[nodegroup]
- if node.name not in nodegroup_obj.members:
+ if node.uuid not in nodegroup_obj.members:
logging.warning("Warning: node '%s' not a member of its node group '%s'"
- " (while being removed from it)", node.name, nodegroup)
+ " (while being removed from it)", node.uuid, nodegroup)
else:
- nodegroup_obj.members.remove(node.name)
+ nodegroup_obj.members.remove(node.uuid)
@locking.ssynchronized(_config_lock)
def AssignGroupNodes(self, mods):
resmod = []
- # Try to resolve names/UUIDs first
- for (node_name, new_group_uuid) in mods:
+ # Try to resolve UUIDs first
+ for (node_uuid, new_group_uuid) in mods:
try:
- node = nodes[node_name]
+ node = nodes[node_uuid]
except KeyError:
- raise errors.ConfigurationError("Unable to find node '%s'" % node_name)
+ raise errors.ConfigurationError("Unable to find node '%s'" % node_uuid)
if node.group == new_group_uuid:
# Node is being assigned to its current group
logging.debug("Node '%s' was assigned to its current group (%s)",
- node_name, node.group)
+ node_uuid, node.group)
continue
# Try to find current group of node
raise errors.ConfigurationError("Unable to find new group '%s'" %
new_group_uuid)
- assert node.name in old_group.members, \
+ assert node.uuid in old_group.members, \
("Inconsistent configuration: node '%s' not listed in members for its"
- " old group '%s'" % (node.name, old_group.uuid))
- assert node.name not in new_group.members, \
+ " old group '%s'" % (node.uuid, old_group.uuid))
+ assert node.uuid not in new_group.members, \
("Inconsistent configuration: node '%s' already listed in members for"
- " its new group '%s'" % (node.name, new_group.uuid))
+ " its new group '%s'" % (node.uuid, new_group.uuid))
resmod.append((node, old_group, new_group))
node.group = new_group.uuid
# Update members of involved groups
- if node.name in old_group.members:
- old_group.members.remove(node.name)
- if node.name not in new_group.members:
- new_group.members.append(node.name)
+ if node.uuid in old_group.members:
+ old_group.members.remove(node.uuid)
+ if node.uuid not in new_group.members:
+ new_group.members.append(node.uuid)
# Update timestamps and serials (only once per node/group object)
now = time.time()
raise errors.ConfigurationError("Incomplete configuration"
" (missing cluster.rsahostkeypub)")
- if data.cluster.master_node != self._my_hostname and not accept_foreign:
+ if not data.cluster.master_node in data.nodes:
+ msg = ("The configuration denotes node %s as master, but does not"
+ " contain information about this node" %
+ data.cluster.master_node)
+ raise errors.ConfigurationError(msg)
+
+ master_info = data.nodes[data.cluster.master_node]
+ if master_info.name != self._my_hostname and not accept_foreign:
msg = ("The configuration denotes node %s as master, while my"
" hostname is %s; opening a foreign configuration is only"
" possible in accept_foreign mode" %
- (data.cluster.master_node, self._my_hostname))
+ (master_info.name, self._my_hostname))
raise errors.ConfigurationError(msg)
self._config_data = data
# nodegroups are being added, and upon normally loading the config,
# because the members list of a node group is discarded upon
# serializing/deserializing the object.
- self._UnlockedAddNodeToGroup(node.name, node.group)
+ self._UnlockedAddNodeToGroup(node.uuid, node.group)
modified = (oldconf != self._config_data.ToDict())
if modified:
# since the node list comes from _UnlocketGetNodeList, and we are
# called with the lock held, so no modifications should take place
# in between
- for node_name in self._UnlockedGetNodeList():
- if node_name == myhostname:
- continue
- node_info = self._UnlockedGetNodeInfo(node_name)
- if not node_info.master_candidate:
+ for node_uuid in self._UnlockedGetNodeList():
+ node_info = self._UnlockedGetNodeInfo(node_uuid)
+ if node_info.name == myhostname or not node_info.master_candidate:
continue
node_list.append(node_info.name)
addr_list.append(node_info.primary_ip)
if self._last_cluster_serial < self._config_data.cluster.serial_no:
if not self._offline:
result = self._GetRpc(None).call_write_ssconf_files(
- self._UnlockedGetOnlineNodeList(),
+ self._UnlockedGetNodeNames(self._UnlockedGetOnlineNodeList()),
self._UnlockedGetSsconfValues())
for nname, nresu in result.items():
self._last_cluster_serial = self._config_data.cluster.serial_no
+ def _GetAllHvparamsStrings(self, hypervisors):
+ """Get the hvparams of all given hypervisors from the config.
+
+ @type hypervisors: list of string
+ @param hypervisors: list of hypervisor names
+ @rtype: dict of strings
+ @returns: dictionary mapping the hypervisor name to a string representation
+ of the hypervisor's hvparams
+
+ """
+ hvparams = {}
+ for hv in hypervisors:
+ hvparams[hv] = self._UnlockedGetHvparamsString(hv)
+ return hvparams
+
+ @staticmethod
+ def _ExtendByAllHvparamsStrings(ssconf_values, all_hvparams):
+ """Extends the ssconf_values dictionary by hvparams.
+
+ @type ssconf_values: dict of strings
+ @param ssconf_values: dictionary mapping ssconf_keys to strings
+ representing the content of ssconf files
+ @type all_hvparams: dict of strings
+ @param all_hvparams: dictionary mapping hypervisor names to a string
+ representation of their hvparams
+ @rtype: same as ssconf_values
+ @returns: the ssconf_values dictionary extended by hvparams
+
+ """
+ for hv in all_hvparams:
+ ssconf_key = constants.SS_HVPARAMS_PREF + hv
+ ssconf_values[ssconf_key] = all_hvparams[hv]
+ return ssconf_values
+
def _UnlockedGetSsconfValues(self):
"""Return the values needed by ssconf.
"""
fn = "\n".join
- instance_names = utils.NiceSort(self._UnlockedGetInstanceList())
- node_names = utils.NiceSort(self._UnlockedGetNodeList())
- node_info = [self._UnlockedGetNodeInfo(name) for name in node_names]
+ instance_names = utils.NiceSort(
+ [inst.name for inst in
+ self._UnlockedGetAllInstancesInfo().values()])
+ node_infos = self._UnlockedGetAllNodesInfo().values()
+ node_names = [node.name for node in node_infos]
node_pri_ips = ["%s %s" % (ninfo.name, ninfo.primary_ip)
- for ninfo in node_info]
+ for ninfo in node_infos]
node_snd_ips = ["%s %s" % (ninfo.name, ninfo.secondary_ip)
- for ninfo in node_info]
+ for ninfo in node_infos]
instance_data = fn(instance_names)
- off_data = fn(node.name for node in node_info if node.offline)
- on_data = fn(node.name for node in node_info if not node.offline)
- mc_data = fn(node.name for node in node_info if node.master_candidate)
- mc_ips_data = fn(node.primary_ip for node in node_info
+ off_data = fn(node.name for node in node_infos if node.offline)
+ on_data = fn(node.name for node in node_infos if not node.offline)
+ mc_data = fn(node.name for node in node_infos if node.master_candidate)
+ mc_ips_data = fn(node.primary_ip for node in node_infos
if node.master_candidate)
node_data = fn(node_names)
node_pri_ips_data = fn(node_pri_ips)
cluster_tags = fn(cluster.GetTags())
hypervisor_list = fn(cluster.enabled_hypervisors)
+ all_hvparams = self._GetAllHvparamsStrings(constants.HYPER_TYPES)
uid_pool = uidpool.FormatUidPool(cluster.uid_pool, separator="\n")
constants.SS_MASTER_IP: cluster.master_ip,
constants.SS_MASTER_NETDEV: cluster.master_netdev,
constants.SS_MASTER_NETMASK: str(cluster.master_netmask),
- constants.SS_MASTER_NODE: cluster.master_node,
+ constants.SS_MASTER_NODE: self._UnlockedGetNodeName(cluster.master_node),
constants.SS_NODE_LIST: node_data,
constants.SS_NODE_PRIMARY_IPS: node_pri_ips_data,
constants.SS_NODE_SECONDARY_IPS: node_snd_ips_data,
constants.SS_NODEGROUPS: nodegroups_data,
constants.SS_NETWORKS: networks_data,
}
+ ssconf_values = self._ExtendByAllHvparamsStrings(ssconf_values,
+ all_hvparams)
bad_values = [(k, v) for k, v in ssconf_values.items()
if not isinstance(v, (str, basestring))]
if bad_values:
self._config_data.cluster.mtime = now
if isinstance(target, objects.Instance):
- self._UnlockedReleaseDRBDMinors(target.name)
+ self._UnlockedReleaseDRBDMinors(target.uuid)
if ec_id is not None:
# Commit all ips reserved by OpInstanceSetParams and OpGroupSetParams
self._EnsureUUID(net, ec_id)
net.serial_no = 1
+ net.ctime = net.mtime = time.time()
self._config_data.networks[net.uuid] = net
self._config_data.cluster.serial_no += 1
self._config_data.cluster.serial_no += 1
self._WriteConfig()
- def _UnlockedGetGroupNetParams(self, net_uuid, node):
+ def _UnlockedGetGroupNetParams(self, net_uuid, node_uuid):
"""Get the netparams (mode, link) of a network.
Get a network's netparams for a given node.
@type net_uuid: string
@param net_uuid: network uuid
- @type node: string
- @param node: node name
+ @type node_uuid: string
+ @param node_uuid: node UUID
@rtype: dict or None
@return: netparams
"""
- node_info = self._UnlockedGetNodeInfo(node)
+ node_info = self._UnlockedGetNodeInfo(node_uuid)
nodegroup_info = self._UnlockedGetNodeGroup(node_info.group)
netparams = nodegroup_info.networks.get(net_uuid, None)
return netparams
@locking.ssynchronized(_config_lock, shared=1)
- def GetGroupNetParams(self, net_uuid, node):
+ def GetGroupNetParams(self, net_uuid, node_uuid):
"""Locking wrapper of _UnlockedGetGroupNetParams()
"""
- return self._UnlockedGetGroupNetParams(net_uuid, node)
+ return self._UnlockedGetGroupNetParams(net_uuid, node_uuid)
@locking.ssynchronized(_config_lock, shared=1)
- def CheckIPInNodeGroup(self, ip, node):
+ def CheckIPInNodeGroup(self, ip, node_uuid):
"""Check IP uniqueness in nodegroup.
Check networks that are connected in the node's node group
@type ip: string
@param ip: ip address
- @type node: string
- @param node: node name
+ @type node_uuid: string
+ @param node_uuid: node UUID
@rtype: (string, dict) or (None, None)
@return: (network name, netparams)
"""
if ip is None:
return (None, None)
- node_info = self._UnlockedGetNodeInfo(node)
+ node_info = self._UnlockedGetNodeInfo(node_uuid)
nodegroup_info = self._UnlockedGetNodeGroup(node_info.group)
for net_uuid in nodegroup_info.networks.keys():
net_info = self._UnlockedGetNetwork(net_uuid)