import ConfigParser
import re
+import copy
from cStringIO import StringIO
from ganeti import errors
class ConfigData(ConfigObject):
"""Top-level config object."""
- __slots__ = ["cluster", "nodes", "instances"]
+ __slots__ = ["version", "cluster", "nodes", "instances", "serial_no"]
def ToDict(self):
"""Custom function for top-level config data.
def CreateOnSecondary(self):
"""Test if this device needs to be created on a secondary node."""
- return self.dev_type in (constants.LD_DRBD7, constants.LD_DRBD8,
- constants.LD_LV)
+ return self.dev_type in (constants.LD_DRBD8, constants.LD_LV)
def AssembleOnSecondary(self):
"""Test if this device needs to be assembled on a secondary node."""
- return self.dev_type in (constants.LD_DRBD7, constants.LD_DRBD8,
- constants.LD_LV)
+ return self.dev_type in (constants.LD_DRBD8, constants.LD_LV)
def OpenOnSecondary(self):
"""Test if this device needs to be opened on a secondary node."""
devices needs to (or can) be assembled.
"""
- if self.dev_type in [constants.LD_LV, constants.LD_MD_R1,
- constants.LD_FILE]:
+ if self.dev_type in [constants.LD_LV, constants.LD_FILE]:
result = [node]
elif self.dev_type in constants.LDS_DRBD:
result = [self.logical_id[0], self.logical_id[1]]
if self.logical_id is None and self.physical_id is not None:
return
if self.dev_type in constants.LDS_DRBD:
- pnode, snode, port = self.logical_id
+ pnode, snode, port, pminor, sminor, secret = self.logical_id
if target_node not in (pnode, snode):
raise errors.ConfigurationError("DRBD device not knowing node %s" %
target_node)
if pnode_ip is None or snode_ip is None:
raise errors.ConfigurationError("Can't find primary or secondary node"
" for %s" % str(self))
+ p_data = (pnode_ip, port)
+ s_data = (snode_ip, port)
if pnode == target_node:
- self.physical_id = (pnode_ip, port,
- snode_ip, port)
+ self.physical_id = p_data + s_data + (pminor, secret)
else: # it must be secondary, we tested above
- self.physical_id = (snode_ip, port,
- pnode_ip, port)
+ self.physical_id = s_data + p_data + (sminor, secret)
else:
self.physical_id = self.logical_id
return
obj.logical_id = tuple(obj.logical_id)
if obj.physical_id and isinstance(obj.physical_id, list):
obj.physical_id = tuple(obj.physical_id)
+ if obj.dev_type in constants.LDS_DRBD:
+ # we need a tuple of length six here
+ if len(obj.logical_id) < 6:
+ obj.logical_id += (None,) * (6 - len(obj.logical_id))
return obj
def __str__(self):
if self.dev_type == constants.LD_LV:
val = "<LogicalVolume(/dev/%s/%s" % self.logical_id
elif self.dev_type in constants.LDS_DRBD:
- if self.dev_type == constants.LD_DRBD7:
- val = "<DRBD7("
- else:
- val = "<DRBD8("
+ val = "<DRBD8("
if self.physical_id is None:
phy = "unconfigured"
else:
val += "backend=%s, metadev=%s" % (self.children[0], self.children[1])
else:
val += "no local storage"
- elif self.dev_type == constants.LD_MD_R1:
- val = "<MD_R1(uuid=%s, children=%s" % (self.physical_id, self.children)
else:
val = ("<Disk(type=%s, logical_id=%s, physical_id=%s, children=%s" %
(self.dev_type, self.logical_id, self.physical_id, self.children))
"name",
"primary_node",
"os",
+ "hypervisor",
+ "hvparams",
+ "beparams",
"status",
- "memory",
- "vcpus",
"nics",
"disks",
"disk_template",
"network_port",
- "kernel_path",
- "initrd_path",
- "hvm_boot_order",
- "hvm_acpi",
- "hvm_pae",
- "hvm_cdrom_image_path",
- "vnc_bind_address",
+ "serial_no",
]
def _ComputeSecondaryNodes(self):
def _Helper(primary, sec_nodes, device):
"""Recursively computes secondary nodes given a top device."""
if device.dev_type in constants.LDS_DRBD:
- nodea, nodeb, dummy = device.logical_id
+ nodea, nodeb, dummy = device.logical_id[:3]
if nodea == primary:
candidate = nodeb
else:
"name",
"path",
"status",
- "api_version",
+ "api_versions",
"create_script",
"export_script",
"import_script",
"name",
"primary_ip",
"secondary_ip",
+ "serial_no",
]
class Cluster(TaggableObject):
"""Config object representing the cluster."""
__slots__ = TaggableObject.__slots__ + [
- "config_version",
"serial_no",
"rsahostkeypub",
"highest_used_port",
"mac_prefix",
"volume_group_name",
"default_bridge",
+ "default_hypervisor",
+ "master_node",
+ "master_ip",
+ "master_netdev",
+ "cluster_name",
+ "file_storage_dir",
+ "enabled_hypervisors",
+ "hvparams",
+ "beparams",
]
def ToDict(self):
obj.tcpudp_port_pool = set(obj.tcpudp_port_pool)
return obj
+ @staticmethod
+ def FillDict(defaults_dict, custom_dict):
+ """Basic function to apply settings on top a default dict.
+
+ @type defaults_dict: dict
+ @param defaults_dict: dictionary holding the default values
+ @type custom_dict: dict
+ @param custom_dict: dictionary holding customized value
+ @rtype: dict
+ @return: dict with the 'full' values
+
+ """
+ ret_dict = copy.deepcopy(defaults_dict)
+ ret_dict.update(custom_dict)
+ return ret_dict
+
+ def FillHV(self, instance):
+ """Fill an instance's hvparams dict.
+
+ @type instance: object
+ @param instance: the instance parameter to fill
+ @rtype: dict
+ @return: a copy of the instance's hvparams with missing keys filled from
+ the cluster defaults
+
+ """
+ return self.FillDict(self.hvparams.get(instance.hypervisor, {}),
+ instance.hvparams)
+
+ def FillBE(self, instance):
+ """Fill an instance's beparams dict.
+
+ @type instance: object
+ @param instance: the instance parameter to fill
+ @rtype: dict
+ @return: a copy of the instance's beparams with missing keys filled from
+ the cluster defaults
+
+ """
+ return self.FillDict(self.beparams.get(constants.BEGR_DEFAULT, {}),
+ instance.beparams)
+
class SerializableConfigParser(ConfigParser.SafeConfigParser):
"""Simple wrapper over ConfigParse that allows serialization.
projects / ganeti-local / blobdiff