#
#
-# Copyright (C) 2006, 2007, 2008, 2009, 2010 Google Inc.
+# Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Google Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
"""
-# pylint: disable-msg=E0203,W0201
+# pylint: disable=E0203,W0201,R0902
# E0203: Access to member %r before its definition, since we use
-# objects.py which doesn't explicitely initialise its members
+# objects.py which doesn't explicitly initialise its members
# W0201: Attribute '%s' defined outside __init__
+# R0902: Allow instances of these objects to have more than 20 attributes
+
import ConfigParser
import re
import copy
+import logging
import time
from cStringIO import StringIO
from ganeti import errors
from ganeti import constants
+from ganeti import netutils
+from ganeti import objectutils
+from ganeti import utils
from socket import AF_INET
__all__ = ["ConfigObject", "ConfigData", "NIC", "Disk", "Instance",
- "OS", "Node", "NodeGroup", "Cluster", "FillDict"]
+ "OS", "Node", "NodeGroup", "Cluster", "FillDict", "Network"]
_TIMESTAMPS = ["ctime", "mtime"]
_UUID = ["uuid"]
return ret_dict
+def FillIPolicy(default_ipolicy, custom_ipolicy, skip_keys=None):
+ """Fills an instance policy with defaults.
+
+ """
+ assert frozenset(default_ipolicy.keys()) == constants.IPOLICY_ALL_KEYS
+ ret_dict = {}
+ for key in constants.IPOLICY_ISPECS:
+ ret_dict[key] = FillDict(default_ipolicy[key],
+ custom_ipolicy.get(key, {}),
+ skip_keys=skip_keys)
+ # list items
+ for key in [constants.IPOLICY_DTS]:
+ ret_dict[key] = list(custom_ipolicy.get(key, default_ipolicy[key]))
+ # other items which we know we can directly copy (immutables)
+ for key in constants.IPOLICY_PARAMETERS:
+ ret_dict[key] = custom_ipolicy.get(key, default_ipolicy[key])
+
+ return ret_dict
+
+
+def FillDiskParams(default_dparams, custom_dparams, skip_keys=None):
+ """Fills the disk parameter defaults.
+
+ @see: L{FillDict} for parameters and return value
+
+ """
+ assert frozenset(default_dparams.keys()) == constants.DISK_TEMPLATES
+
+ return dict((dt, FillDict(default_dparams[dt], custom_dparams.get(dt, {}),
+ skip_keys=skip_keys))
+ for dt in constants.DISK_TEMPLATES)
+
+
def UpgradeGroupedParams(target, defaults):
"""Update all groups for the target parameter.
return target
-class ConfigObject(object):
+def UpgradeBeParams(target):
+ """Update the be parameters dict to the new format.
+
+ @type target: dict
+ @param target: "be" parameters dict
+
+ """
+ if constants.BE_MEMORY in target:
+ memory = target[constants.BE_MEMORY]
+ target[constants.BE_MAXMEM] = memory
+ target[constants.BE_MINMEM] = memory
+ del target[constants.BE_MEMORY]
+
+
+def UpgradeDiskParams(diskparams):
+ """Upgrade the disk parameters.
+
+ @type diskparams: dict
+ @param diskparams: disk parameters to upgrade
+ @rtype: dict
+ @return: the upgraded disk parameters dict
+
+ """
+ if not diskparams:
+ result = {}
+ else:
+ result = FillDiskParams(constants.DISK_DT_DEFAULTS, diskparams)
+
+ return result
+
+
+def UpgradeNDParams(ndparams):
+ """Upgrade ndparams structure.
+
+ @type ndparams: dict
+ @param ndparams: disk parameters to upgrade
+ @rtype: dict
+ @return: the upgraded node parameters dict
+
+ """
+ if ndparams is None:
+ ndparams = {}
+
+ if (constants.ND_OOB_PROGRAM in ndparams and
+ ndparams[constants.ND_OOB_PROGRAM] is None):
+ # will be reset by the line below
+ del ndparams[constants.ND_OOB_PROGRAM]
+ return FillDict(constants.NDC_DEFAULTS, ndparams)
+
+
+def MakeEmptyIPolicy():
+ """Create empty IPolicy dictionary.
+
+ """
+ return dict([
+ (constants.ISPECS_MIN, {}),
+ (constants.ISPECS_MAX, {}),
+ (constants.ISPECS_STD, {}),
+ ])
+
+
+class ConfigObject(objectutils.ValidatedSlots):
"""A generic config object.
It has the following properties:
"""
__slots__ = []
- def __init__(self, **kwargs):
- for k, v in kwargs.iteritems():
- setattr(self, k, v)
-
def __getattr__(self, name):
- if name not in self._all_slots():
+ if name not in self.GetAllSlots():
raise AttributeError("Invalid object attribute %s.%s" %
(type(self).__name__, name))
return None
def __setstate__(self, state):
- slots = self._all_slots()
+ slots = self.GetAllSlots()
for name in state:
if name in slots:
setattr(self, name, state[name])
- @classmethod
- def _all_slots(cls):
- """Compute the list of all declared slots for a class.
+ def Validate(self):
+ """Validates the slots.
"""
- slots = []
- for parent in cls.__mro__:
- slots.extend(getattr(parent, "__slots__", []))
- return slots
def ToDict(self):
"""Convert to a dict holding only standard python types.
"""
result = {}
- for name in self._all_slots():
+ for name in self.GetAllSlots():
value = getattr(self, name, None)
if value is not None:
result[name] = value
raise errors.ConfigurationError("Invalid object passed to FromDict:"
" expected dict, got %s" % type(val))
val_str = dict([(str(k), v) for k, v in val.iteritems()])
- obj = cls(**val_str) # pylint: disable-msg=W0142
+ obj = cls(**val_str) # pylint: disable=W0142
return obj
@staticmethod
return obj
+class MasterNetworkParameters(ConfigObject):
+ """Network configuration parameters for the master
+
+ @ivar name: master name
+ @ivar ip: master IP
+ @ivar netmask: master netmask
+ @ivar netdev: master network device
+ @ivar ip_family: master IP family
+
+ """
+ __slots__ = [
+ "name",
+ "ip",
+ "netmask",
+ "netdev",
+ "ip_family",
+ ]
+
+
class ConfigData(ConfigObject):
"""Top-level config object."""
__slots__ = [
"nodes",
"nodegroups",
"instances",
+ "networks",
"serial_no",
] + _TIMESTAMPS
"""
mydict = super(ConfigData, self).ToDict()
mydict["cluster"] = mydict["cluster"].ToDict()
- for key in "nodes", "instances", "nodegroups":
+ for key in "nodes", "instances", "nodegroups", "networks":
mydict[key] = self._ContainerToDicts(mydict[key])
return mydict
obj.nodes = cls._ContainerFromDicts(obj.nodes, dict, Node)
obj.instances = cls._ContainerFromDicts(obj.instances, dict, Instance)
obj.nodegroups = cls._ContainerFromDicts(obj.nodegroups, dict, NodeGroup)
+ obj.networks = cls._ContainerFromDicts(obj.networks, dict, Network)
return obj
def HasAnyDiskOfType(self, dev_type):
# gives a good approximation.
if self.HasAnyDiskOfType(constants.LD_DRBD8):
self.cluster.drbd_usermode_helper = constants.DEFAULT_DRBD_HELPER
+ if self.networks is None:
+ self.networks = {}
+ for network in self.networks.values():
+ network.UpgradeConfig()
class NIC(ConfigObject):
"""Config object representing a network card."""
- __slots__ = ["mac", "ip", "nicparams"]
+ __slots__ = ["mac", "ip", "network", "nicparams", "netinfo"]
@classmethod
def CheckParameterSyntax(cls, nicparams):
@raise errors.ConfigurationError: when a parameter is not valid
"""
- if nicparams[constants.NIC_MODE] not in constants.NIC_VALID_MODES:
- err = "Invalid nic mode: %s" % nicparams[constants.NIC_MODE]
- raise errors.ConfigurationError(err)
+ mode = nicparams[constants.NIC_MODE]
+ if (mode not in constants.NIC_VALID_MODES and
+ mode != constants.VALUE_AUTO):
+ raise errors.ConfigurationError("Invalid NIC mode '%s'" % mode)
- if (nicparams[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED and
+ if (mode == constants.NIC_MODE_BRIDGED and
not nicparams[constants.NIC_LINK]):
- err = "Missing bridged nic link"
- raise errors.ConfigurationError(err)
+ raise errors.ConfigurationError("Missing bridged NIC link")
class Disk(ConfigObject):
"""Config object representing a block device."""
__slots__ = ["dev_type", "logical_id", "physical_id",
- "children", "iv_name", "size", "mode"]
+ "children", "iv_name", "size", "mode", "params"]
def CreateOnSecondary(self):
"""Test if this device needs to be created on a secondary node."""
"""
if self.dev_type == constants.LD_LV:
return "/dev/%s/%s" % (self.logical_id[0], self.logical_id[1])
+ elif self.dev_type == constants.LD_BLOCKDEV:
+ return self.logical_id[1]
+ elif self.dev_type == constants.LD_RBD:
+ return "/dev/%s/%s" % (self.logical_id[0], self.logical_id[1])
return None
def ChildrenNeeded(self):
devices needs to (or can) be assembled.
"""
- if self.dev_type in [constants.LD_LV, constants.LD_FILE]:
+ if self.dev_type in [constants.LD_LV, constants.LD_FILE,
+ constants.LD_BLOCKDEV, constants.LD_RBD,
+ constants.LD_EXT]:
result = [node]
elif self.dev_type in constants.LDS_DRBD:
result = [self.logical_id[0], self.logical_id[1]]
# be different)
return result
+ def ComputeGrowth(self, amount):
+ """Compute the per-VG growth requirements.
+
+ This only works for VG-based disks.
+
+ @type amount: integer
+ @param amount: the desired increase in (user-visible) disk space
+ @rtype: dict
+ @return: a dictionary of volume-groups and the required size
+
+ """
+ if self.dev_type == constants.LD_LV:
+ return {self.logical_id[0]: amount}
+ elif self.dev_type == constants.LD_DRBD8:
+ if self.children:
+ return self.children[0].ComputeGrowth(amount)
+ else:
+ return {}
+ else:
+ # Other disk types do not require VG space
+ return {}
+
def RecordGrow(self, amount):
"""Update the size of this disk after growth.
actual algorithms from bdev.
"""
- if self.dev_type == constants.LD_LV or self.dev_type == constants.LD_FILE:
+ if self.dev_type in (constants.LD_LV, constants.LD_FILE,
+ constants.LD_RBD, constants.LD_EXT):
self.size += amount
elif self.dev_type == constants.LD_DRBD8:
if self.children:
raise errors.ProgrammerError("Disk.RecordGrow called for unsupported"
" disk type %s" % self.dev_type)
+ def Update(self, size=None, mode=None):
+ """Apply changes to size and mode.
+
+ """
+ if self.dev_type == constants.LD_DRBD8:
+ if self.children:
+ self.children[0].Update(size=size, mode=mode)
+ else:
+ assert not self.children
+
+ if size is not None:
+ self.size = size
+ if mode is not None:
+ self.mode = mode
+
def UnsetSize(self):
"""Sets recursively the size to zero for the disk and its children.
"""
if self.dev_type == constants.LD_LV:
- val = "<LogicalVolume(/dev/%s/%s" % self.logical_id
+ val = "<LogicalVolume(/dev/%s/%s" % self.logical_id
elif self.dev_type in constants.LDS_DRBD:
node_a, node_b, port, minor_a, minor_b = self.logical_id[:5]
val = "<DRBD8("
if self.children:
for child in self.children:
child.UpgradeConfig()
+
+ # FIXME: Make this configurable in Ganeti 2.7
+ self.params = {}
# add here config upgrade for this disk
+ @staticmethod
+ def ComputeLDParams(disk_template, disk_params):
+ """Computes Logical Disk parameters from Disk Template parameters.
+
+ @type disk_template: string
+ @param disk_template: disk template, one of L{constants.DISK_TEMPLATES}
+ @type disk_params: dict
+ @param disk_params: disk template parameters;
+ dict(template_name -> parameters
+ @rtype: list(dict)
+ @return: a list of dicts, one for each node of the disk hierarchy. Each dict
+ contains the LD parameters of the node. The tree is flattened in-order.
+
+ """
+ if disk_template not in constants.DISK_TEMPLATES:
+ raise errors.ProgrammerError("Unknown disk template %s" % disk_template)
+
+ assert disk_template in disk_params
+
+ result = list()
+ dt_params = disk_params[disk_template]
+ if disk_template == constants.DT_DRBD8:
+ result.append(FillDict(constants.DISK_LD_DEFAULTS[constants.LD_DRBD8], {
+ constants.LDP_RESYNC_RATE: dt_params[constants.DRBD_RESYNC_RATE],
+ constants.LDP_BARRIERS: dt_params[constants.DRBD_DISK_BARRIERS],
+ constants.LDP_NO_META_FLUSH: dt_params[constants.DRBD_META_BARRIERS],
+ constants.LDP_DEFAULT_METAVG: dt_params[constants.DRBD_DEFAULT_METAVG],
+ constants.LDP_DISK_CUSTOM: dt_params[constants.DRBD_DISK_CUSTOM],
+ constants.LDP_NET_CUSTOM: dt_params[constants.DRBD_NET_CUSTOM],
+ constants.LDP_DYNAMIC_RESYNC: dt_params[constants.DRBD_DYNAMIC_RESYNC],
+ constants.LDP_PLAN_AHEAD: dt_params[constants.DRBD_PLAN_AHEAD],
+ constants.LDP_FILL_TARGET: dt_params[constants.DRBD_FILL_TARGET],
+ constants.LDP_DELAY_TARGET: dt_params[constants.DRBD_DELAY_TARGET],
+ constants.LDP_MAX_RATE: dt_params[constants.DRBD_MAX_RATE],
+ constants.LDP_MIN_RATE: dt_params[constants.DRBD_MIN_RATE],
+ }))
+
+ # data LV
+ result.append(FillDict(constants.DISK_LD_DEFAULTS[constants.LD_LV], {
+ constants.LDP_STRIPES: dt_params[constants.DRBD_DATA_STRIPES],
+ }))
+
+ # metadata LV
+ result.append(FillDict(constants.DISK_LD_DEFAULTS[constants.LD_LV], {
+ constants.LDP_STRIPES: dt_params[constants.DRBD_META_STRIPES],
+ }))
+
+ elif disk_template in (constants.DT_FILE, constants.DT_SHARED_FILE):
+ result.append(constants.DISK_LD_DEFAULTS[constants.LD_FILE])
+
+ elif disk_template == constants.DT_PLAIN:
+ result.append(FillDict(constants.DISK_LD_DEFAULTS[constants.LD_LV], {
+ constants.LDP_STRIPES: dt_params[constants.LV_STRIPES],
+ }))
+
+ elif disk_template == constants.DT_BLOCK:
+ result.append(constants.DISK_LD_DEFAULTS[constants.LD_BLOCKDEV])
+
+ elif disk_template == constants.DT_RBD:
+ result.append(FillDict(constants.DISK_LD_DEFAULTS[constants.LD_RBD], {
+ constants.LDP_POOL: dt_params[constants.RBD_POOL],
+ }))
+
+ elif disk_template == constants.DT_EXT:
+ result.append(constants.DISK_LD_DEFAULTS[constants.LD_EXT])
+
+ return result
+
+
+class InstancePolicy(ConfigObject):
+ """Config object representing instance policy limits dictionary.
+
+
+ Note that this object is not actually used in the config, it's just
+ used as a placeholder for a few functions.
+
+ """
+ @classmethod
+ def CheckParameterSyntax(cls, ipolicy, check_std):
+ """ Check the instance policy for validity.
+
+ """
+ for param in constants.ISPECS_PARAMETERS:
+ InstancePolicy.CheckISpecSyntax(ipolicy, param, check_std)
+ if constants.IPOLICY_DTS in ipolicy:
+ InstancePolicy.CheckDiskTemplates(ipolicy[constants.IPOLICY_DTS])
+ for key in constants.IPOLICY_PARAMETERS:
+ if key in ipolicy:
+ InstancePolicy.CheckParameter(key, ipolicy[key])
+ wrong_keys = frozenset(ipolicy.keys()) - constants.IPOLICY_ALL_KEYS
+ if wrong_keys:
+ raise errors.ConfigurationError("Invalid keys in ipolicy: %s" %
+ utils.CommaJoin(wrong_keys))
+
+ @classmethod
+ def CheckISpecSyntax(cls, ipolicy, name, check_std):
+ """Check the instance policy for validity on a given key.
+
+ We check if the instance policy makes sense for a given key, that is
+ if ipolicy[min][name] <= ipolicy[std][name] <= ipolicy[max][name].
+
+ @type ipolicy: dict
+ @param ipolicy: dictionary with min, max, std specs
+ @type name: string
+ @param name: what are the limits for
+ @type check_std: bool
+ @param check_std: Whether to check std value or just assume compliance
+ @raise errors.ConfigureError: when specs for given name are not valid
+
+ """
+ min_v = ipolicy[constants.ISPECS_MIN].get(name, 0)
+
+ if check_std:
+ std_v = ipolicy[constants.ISPECS_STD].get(name, min_v)
+ std_msg = std_v
+ else:
+ std_v = min_v
+ std_msg = "-"
+
+ max_v = ipolicy[constants.ISPECS_MAX].get(name, std_v)
+ err = ("Invalid specification of min/max/std values for %s: %s/%s/%s" %
+ (name,
+ ipolicy[constants.ISPECS_MIN].get(name, "-"),
+ ipolicy[constants.ISPECS_MAX].get(name, "-"),
+ std_msg))
+ if min_v > std_v or std_v > max_v:
+ raise errors.ConfigurationError(err)
+
+ @classmethod
+ def CheckDiskTemplates(cls, disk_templates):
+ """Checks the disk templates for validity.
+
+ """
+ wrong = frozenset(disk_templates).difference(constants.DISK_TEMPLATES)
+ if wrong:
+ raise errors.ConfigurationError("Invalid disk template(s) %s" %
+ utils.CommaJoin(wrong))
+
+ @classmethod
+ def CheckParameter(cls, key, value):
+ """Checks a parameter.
+
+ Currently we expect all parameters to be float values.
+
+ """
+ try:
+ float(value)
+ except (TypeError, ValueError), err:
+ raise errors.ConfigurationError("Invalid value for key" " '%s':"
+ " '%s', error: %s" % (key, value, err))
+
class Instance(TaggableObject):
"""Config object representing an instance."""
"hvparams",
"beparams",
"osparams",
- "admin_up",
+ "admin_state",
"nics",
"disks",
"disk_template",
return tuple(all_nodes)
secondary_nodes = property(_ComputeSecondaryNodes, None, None,
- "List of secondary nodes")
+ "List of names of secondary nodes")
def _ComputeAllNodes(self):
"""Compute the list of all nodes.
return tuple(all_nodes)
all_nodes = property(_ComputeAllNodes, None, None,
- "List of all nodes of the instance")
+ "List of names of all the nodes of the instance")
def MapLVsByNode(self, lvmap=None, devs=None, node=None):
"""Provide a mapping of nodes to LVs this instance owns.
GetVolumeList()
"""
- if node == None:
+ if node is None:
node = self.primary_node
if lvmap is None:
- lvmap = { node : [] }
+ lvmap = {
+ node: [],
+ }
ret = lvmap
else:
if not node in lvmap:
for dev in devs:
if dev.dev_type == constants.LD_LV:
- lvmap[node].append(dev.logical_id[0]+"/"+dev.logical_id[1])
+ lvmap[node].append(dev.logical_id[0] + "/" + dev.logical_id[1])
elif dev.dev_type in constants.LDS_DRBD:
if dev.children:
errors.ECODE_INVAL)
except IndexError:
raise errors.OpPrereqError("Invalid disk index: %d (instace has disks"
- " 0 to %d" % (idx, len(self.disks)),
+ " 0 to %d" % (idx, len(self.disks) - 1),
errors.ECODE_INVAL)
def ToDict(self):
"""Custom function for instances.
"""
+ if "admin_state" not in val:
+ if val.get("admin_up", False):
+ val["admin_state"] = constants.ADMINST_UP
+ else:
+ val["admin_state"] = constants.ADMINST_DOWN
+ if "admin_up" in val:
+ del val["admin_up"]
obj = super(Instance, cls).FromDict(val)
obj.nics = cls._ContainerFromDicts(obj.nics, list, NIC)
obj.disks = cls._ContainerFromDicts(obj.disks, list, Disk)
pass
if self.osparams is None:
self.osparams = {}
+ UpgradeBeParams(self.beparams)
class OS(ConfigObject):
return cls.SplitNameVariant(name)[1]
+class ExtStorage(ConfigObject):
+ """Config object representing an External Storage Provider.
+
+ """
+ __slots__ = [
+ "name",
+ "path",
+ "create_script",
+ "remove_script",
+ "grow_script",
+ "attach_script",
+ "detach_script",
+ "setinfo_script",
+ "verify_script",
+ "supported_parameters",
+ ]
+
+
+class NodeHvState(ConfigObject):
+ """Hypvervisor state on a node.
+
+ @ivar mem_total: Total amount of memory
+ @ivar mem_node: Memory used by, or reserved for, the node itself (not always
+ available)
+ @ivar mem_hv: Memory used by hypervisor or lost due to instance allocation
+ rounding
+ @ivar mem_inst: Memory used by instances living on node
+ @ivar cpu_total: Total node CPU core count
+ @ivar cpu_node: Number of CPU cores reserved for the node itself
+
+ """
+ __slots__ = [
+ "mem_total",
+ "mem_node",
+ "mem_hv",
+ "mem_inst",
+ "cpu_total",
+ "cpu_node",
+ ] + _TIMESTAMPS
+
+
+class NodeDiskState(ConfigObject):
+ """Disk state on a node.
+
+ """
+ __slots__ = [
+ "total",
+ "reserved",
+ "overhead",
+ ] + _TIMESTAMPS
+
+
class Node(TaggableObject):
- """Config object representing a node."""
+ """Config object representing a node.
+
+ @ivar hv_state: Hypervisor state (e.g. number of CPUs)
+ @ivar hv_state_static: Hypervisor state overriden by user
+ @ivar disk_state: Disk state (e.g. free space)
+ @ivar disk_state_static: Disk state overriden by user
+
+ """
__slots__ = [
"name",
"primary_ip",
"master_capable",
"vm_capable",
"ndparams",
+ "powered",
+ "hv_state",
+ "hv_state_static",
+ "disk_state",
+ "disk_state_static",
] + _TIMESTAMPS + _UUID
def UpgradeConfig(self):
"""Fill defaults for missing configuration values.
"""
- # pylint: disable-msg=E0203
+ # pylint: disable=E0203
# because these are "defined" via slots, not manually
if self.master_capable is None:
self.master_capable = True
if self.ndparams is None:
self.ndparams = {}
+ # And remove any global parameter
+ for key in constants.NDC_GLOBALS:
+ if key in self.ndparams:
+ logging.warning("Ignoring %s node parameter for node %s",
+ key, self.name)
+ del self.ndparams[key]
+
+ if self.powered is None:
+ self.powered = True
+
+ def ToDict(self):
+ """Custom function for serializing.
+
+ """
+ data = super(Node, self).ToDict()
+
+ hv_state = data.get("hv_state", None)
+ if hv_state is not None:
+ data["hv_state"] = self._ContainerToDicts(hv_state)
+
+ disk_state = data.get("disk_state", None)
+ if disk_state is not None:
+ data["disk_state"] = \
+ dict((key, self._ContainerToDicts(value))
+ for (key, value) in disk_state.items())
+
+ return data
+
+ @classmethod
+ def FromDict(cls, val):
+ """Custom function for deserializing.
+
+ """
+ obj = super(Node, cls).FromDict(val)
+
+ if obj.hv_state is not None:
+ obj.hv_state = cls._ContainerFromDicts(obj.hv_state, dict, NodeHvState)
+
+ if obj.disk_state is not None:
+ obj.disk_state = \
+ dict((key, cls._ContainerFromDicts(value, dict, NodeDiskState))
+ for (key, value) in obj.disk_state.items())
+
+ return obj
-class NodeGroup(ConfigObject):
+class NodeGroup(TaggableObject):
"""Config object representing a node group."""
__slots__ = [
"name",
"members",
"ndparams",
+ "diskparams",
+ "ipolicy",
"serial_no",
+ "hv_state_static",
+ "disk_state_static",
+ "alloc_policy",
+ "networks",
] + _TIMESTAMPS + _UUID
def ToDict(self):
if self.serial_no is None:
self.serial_no = 1
- # We only update mtime, and not ctime, since we would not be able to provide
- # a correct value for creation time.
+ if self.alloc_policy is None:
+ self.alloc_policy = constants.ALLOC_POLICY_PREFERRED
+
+ # We only update mtime, and not ctime, since we would not be able
+ # to provide a correct value for creation time.
if self.mtime is None:
self.mtime = time.time()
+ if self.diskparams is None:
+ self.diskparams = {}
+ if self.ipolicy is None:
+ self.ipolicy = MakeEmptyIPolicy()
+
+ if self.networks is None:
+ self.networks = {}
+
def FillND(self, node):
- """Return filled out ndparams for L{object.Node}
+ """Return filled out ndparams for L{objects.Node}
@type node: L{objects.Node}
@param node: A Node object to fill
"master_node",
"master_ip",
"master_netdev",
+ "master_netmask",
+ "use_external_mip_script",
"cluster_name",
"file_storage_dir",
+ "shared_file_storage_dir",
"enabled_hypervisors",
"hvparams",
+ "ipolicy",
"os_hvp",
"beparams",
"osparams",
"nicparams",
"ndparams",
+ "diskparams",
"candidate_pool_size",
"modify_etc_hosts",
"modify_ssh_setup",
"blacklisted_os",
"primary_ip_family",
"prealloc_wipe_disks",
+ "hv_state_static",
+ "disk_state_static",
] + _TIMESTAMPS + _UUID
def UpgradeConfig(self):
"""Fill defaults for missing configuration values.
"""
- # pylint: disable-msg=E0203
+ # pylint: disable=E0203
# because these are "defined" via slots, not manually
if self.hvparams is None:
self.hvparams = constants.HVC_DEFAULTS
if self.osparams is None:
self.osparams = {}
- if self.ndparams is None:
- self.ndparams = constants.NDC_DEFAULTS
+ self.ndparams = UpgradeNDParams(self.ndparams)
self.beparams = UpgradeGroupedParams(self.beparams,
constants.BEC_DEFAULTS)
+ for beparams_group in self.beparams:
+ UpgradeBeParams(self.beparams[beparams_group])
+
migrate_default_bridge = not self.nicparams
self.nicparams = UpgradeGroupedParams(self.nicparams,
constants.NICC_DEFAULTS)
if self.modify_ssh_setup is None:
self.modify_ssh_setup = True
- # default_bridge is no longer used it 2.1. The slot is left there to
+ # default_bridge is no longer used in 2.1. The slot is left there to
# support auto-upgrading. It can be removed once we decide to deprecate
# upgrading straight from 2.0.
if self.default_bridge is not None:
# code can be removed once upgrading straight from 2.0 is deprecated.
if self.default_hypervisor is not None:
self.enabled_hypervisors = ([self.default_hypervisor] +
- [hvname for hvname in self.enabled_hypervisors
- if hvname != self.default_hypervisor])
+ [hvname for hvname in self.enabled_hypervisors
+ if hvname != self.default_hypervisor])
self.default_hypervisor = None
# maintain_node_health added after 2.1.1
if self.primary_ip_family is None:
self.primary_ip_family = AF_INET
+ if self.master_netmask is None:
+ ipcls = netutils.IPAddress.GetClassFromIpFamily(self.primary_ip_family)
+ self.master_netmask = ipcls.iplen
+
if self.prealloc_wipe_disks is None:
self.prealloc_wipe_disks = False
+ # shared_file_storage_dir added before 2.5
+ if self.shared_file_storage_dir is None:
+ self.shared_file_storage_dir = ""
+
+ if self.use_external_mip_script is None:
+ self.use_external_mip_script = False
+
+ if self.diskparams:
+ self.diskparams = UpgradeDiskParams(self.diskparams)
+ else:
+ self.diskparams = constants.DISK_DT_DEFAULTS.copy()
+
+ # instance policy added before 2.6
+ if self.ipolicy is None:
+ self.ipolicy = FillIPolicy(constants.IPOLICY_DEFAULTS, {})
+ else:
+ # we can either make sure to upgrade the ipolicy always, or only
+ # do it in some corner cases (e.g. missing keys); note that this
+ # will break any removal of keys from the ipolicy dict
+ self.ipolicy = FillIPolicy(constants.IPOLICY_DEFAULTS, self.ipolicy)
+
+ @property
+ def primary_hypervisor(self):
+ """The first hypervisor is the primary.
+
+ Useful, for example, for L{Node}'s hv/disk state.
+
+ """
+ return self.enabled_hypervisors[0]
+
def ToDict(self):
"""Custom function for cluster.
obj.tcpudp_port_pool = set(obj.tcpudp_port_pool)
return obj
+ def SimpleFillDP(self, diskparams):
+ """Fill a given diskparams dict with cluster defaults.
+
+ @param diskparams: The diskparams
+ @return: The defaults dict
+
+ """
+ return FillDiskParams(self.diskparams, diskparams)
+
def GetHVDefaults(self, hypervisor, os_name=None, skip_keys=None):
"""Get the default hypervisor parameters for the cluster.
# specified params
return FillDict(result, os_params)
+ @staticmethod
+ def SimpleFillHvState(hv_state):
+ """Fill an hv_state sub dict with cluster defaults.
+
+ """
+ return FillDict(constants.HVST_DEFAULTS, hv_state)
+
+ @staticmethod
+ def SimpleFillDiskState(disk_state):
+ """Fill an disk_state sub dict with cluster defaults.
+
+ """
+ return FillDict(constants.DS_DEFAULTS, disk_state)
+
def FillND(self, node, nodegroup):
- """Return filled out ndparams for L{objects.NodeGroup} and L{object.Node}
+ """Return filled out ndparams for L{objects.NodeGroup} and L{objects.Node}
@type node: L{objects.Node}
@param node: A Node object to fill
"""
return FillDict(self.ndparams, ndparams)
+ def SimpleFillIPolicy(self, ipolicy):
+ """ Fill instance policy dict with defaults.
+
+ @type ipolicy: dict
+ @param ipolicy: the dict to fill
+ @rtype: dict
+ @return: a copy of passed ipolicy with missing keys filled from
+ the cluster defaults
+
+ """
+ return FillIPolicy(self.ipolicy, ipolicy)
+
class BlockDevStatus(ConfigObject):
"""Config object representing the status of a block device."""
@ivar compress: Compression method (one of L{constants.IEC_ALL})
@ivar magic: Used to ensure the connection goes to the right disk
@ivar ipv6: Whether to use IPv6
+ @ivar connect_timeout: Number of seconds for establishing connection
"""
__slots__ = [
"compress",
"magic",
"ipv6",
+ "connect_timeout",
]
@ivar name: Field name
@ivar title: Human-readable title
@ivar kind: Field type
+ @ivar doc: Human-readable description
"""
__slots__ = [
"name",
"title",
"kind",
+ "doc",
]
-class QueryRequest(ConfigObject):
- """Object holding a query request.
-
- """
+class _QueryResponseBase(ConfigObject):
__slots__ = [
- "what",
"fields",
- "filter",
]
+ def ToDict(self):
+ """Custom function for serializing.
+
+ """
+ mydict = super(_QueryResponseBase, self).ToDict()
+ mydict["fields"] = self._ContainerToDicts(mydict["fields"])
+ return mydict
+
+ @classmethod
+ def FromDict(cls, val):
+ """Custom function for de-serializing.
+
+ """
+ obj = super(_QueryResponseBase, cls).FromDict(val)
+ obj.fields = cls._ContainerFromDicts(obj.fields, list, QueryFieldDefinition)
+ return obj
+
-class QueryResponse(ConfigObject):
+class QueryResponse(_QueryResponseBase):
"""Object holding the response to a query.
@ivar fields: List of L{QueryFieldDefinition} objects
"""
__slots__ = [
- "fields",
"data",
]
]
-class QueryFieldsResponse(ConfigObject):
+class QueryFieldsResponse(_QueryResponseBase):
"""Object holding the response to a query for fields.
@ivar fields: List of L{QueryFieldDefinition} objects
"""
+ __slots__ = []
+
+
+class MigrationStatus(ConfigObject):
+ """Object holding the status of a migration.
+
+ """
__slots__ = [
- "fields",
+ "status",
+ "transferred_ram",
+ "total_ram",
+ ]
+
+
+class InstanceConsole(ConfigObject):
+ """Object describing how to access the console of an instance.
+
+ """
+ __slots__ = [
+ "instance",
+ "kind",
+ "message",
+ "host",
+ "port",
+ "user",
+ "command",
+ "display",
]
+ def Validate(self):
+ """Validates contents of this object.
+
+ """
+ assert self.kind in constants.CONS_ALL, "Unknown console type"
+ assert self.instance, "Missing instance name"
+ assert self.message or self.kind in [constants.CONS_SSH,
+ constants.CONS_SPICE,
+ constants.CONS_VNC]
+ assert self.host or self.kind == constants.CONS_MESSAGE
+ assert self.port or self.kind in [constants.CONS_MESSAGE,
+ constants.CONS_SSH]
+ assert self.user or self.kind in [constants.CONS_MESSAGE,
+ constants.CONS_SPICE,
+ constants.CONS_VNC]
+ assert self.command or self.kind in [constants.CONS_MESSAGE,
+ constants.CONS_SPICE,
+ constants.CONS_VNC]
+ assert self.display or self.kind in [constants.CONS_MESSAGE,
+ constants.CONS_SPICE,
+ constants.CONS_SSH]
+ return True
+
+
+class Network(TaggableObject):
+ """Object representing a network definition for ganeti.
+
+ """
+ __slots__ = [
+ "name",
+ "serial_no",
+ "network_type",
+ "mac_prefix",
+ "family",
+ "network",
+ "network6",
+ "gateway",
+ "gateway6",
+ "size",
+ "reservations",
+ "ext_reservations",
+ ] + _TIMESTAMPS + _UUID
+
+ def HooksDict(self, prefix):
+ """Export a dictionary used by hooks with a network's information.
+
+ @type prefix: String
+ @param prefix: Prefix to prepend to the dict entries
+
+ """
+ result = {
+ "%sNETWORK" % prefix: self.name,
+ "%sNETWORK_UUID" % prefix: self.uuid,
+ "%sNETWORK_FAMILY" % prefix: str(self.family),
+ "%sNETWORK_TAGS" % prefix: " ".join(self.tags),
+ }
+ if self.network:
+ result["%sNETWORK_SUBNET" % prefix] = self.network
+ if self.gateway:
+ result["%sNETWORK_GATEWAY" % prefix] = self.gateway
+ if self.network6:
+ result["%sNETWORK_SUBNET6" % prefix] = self.network6
+ if self.gateway6:
+ result["%sNETWORK_GATEWAY6" % prefix] = self.gateway6
+ if self.mac_prefix:
+ result["%sNETWORK_MAC_PREFIX" % prefix] = self.mac_prefix
+ if self.network_type:
+ result["%sNETWORK_TYPE" % prefix] = self.network_type
+
+ return result
+
class SerializableConfigParser(ConfigParser.SafeConfigParser):
"""Simple wrapper over ConfigParse that allows serialization.
cfp = cls()
cfp.readfp(buf)
return cfp
+
+
+class LvmPvInfo(ConfigObject):
+ """Information about an LVM physical volume (PV).
+
+ @type name: string
+ @ivar name: name of the PV
+ @type vg_name: string
+ @ivar vg_name: name of the volume group containing the PV
+ @type size: float
+ @ivar size: size of the PV in MiB
+ @type free: float
+ @ivar free: free space in the PV, in MiB
+ @type attributes: string
+ @ivar attributes: PV attributes
+ @type lv_list: list of strings
+ @ivar lv_list: names of the LVs hosted on the PV
+ """
+ __slots__ = [
+ "name",
+ "vg_name",
+ "size",
+ "free",
+ "attributes",
+ "lv_list"
+ ]
+
+ def IsEmpty(self):
+ """Is this PV empty?
+
+ """
+ return self.size <= (self.free + 1)
+
+ def IsAllocatable(self):
+ """Is this PV allocatable?
+
+ """
+ return ("a" in self.attributes)