#
#
-# Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Google Inc.
+# Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 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
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 outils
from ganeti import utils
from socket import AF_INET
])
-class ConfigObject(objectutils.ValidatedSlots):
+class ConfigObject(outils.ValidatedSlots):
"""A generic config object.
It has the following properties:
obj = cls(**val_str) # pylint: disable=W0142
return obj
- @staticmethod
- def _ContainerToDicts(container):
- """Convert the elements of a container to standard python types.
-
- This method converts a container with elements derived from
- ConfigData to standard python types. If the container is a dict,
- we don't touch the keys, only the values.
-
- """
- if isinstance(container, dict):
- ret = dict([(k, v.ToDict()) for k, v in container.iteritems()])
- elif isinstance(container, (list, tuple, set, frozenset)):
- ret = [elem.ToDict() for elem in container]
- else:
- raise TypeError("Invalid type %s passed to _ContainerToDicts" %
- type(container))
- return ret
-
- @staticmethod
- def _ContainerFromDicts(source, c_type, e_type):
- """Convert a container from standard python types.
-
- This method converts a container with standard python types to
- ConfigData objects. If the container is a dict, we don't touch the
- keys, only the values.
-
- """
- if not isinstance(c_type, type):
- raise TypeError("Container type %s passed to _ContainerFromDicts is"
- " not a type" % type(c_type))
- if source is None:
- source = c_type()
- if c_type is dict:
- ret = dict([(k, e_type.FromDict(v)) for k, v in source.iteritems()])
- elif c_type in (list, tuple, set, frozenset):
- ret = c_type([e_type.FromDict(elem) for elem in source])
- else:
- raise TypeError("Invalid container type %s passed to"
- " _ContainerFromDicts" % c_type)
- return ret
-
def Copy(self):
"""Makes a deep copy of the current object and its children.
mydict = super(ConfigData, self).ToDict()
mydict["cluster"] = mydict["cluster"].ToDict()
for key in "nodes", "instances", "nodegroups", "networks":
- mydict[key] = self._ContainerToDicts(mydict[key])
+ mydict[key] = outils.ContainerToDicts(mydict[key])
return mydict
"""
obj = super(ConfigData, cls).FromDict(val)
obj.cluster = Cluster.FromDict(obj.cluster)
- 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)
+ obj.nodes = outils.ContainerFromDicts(obj.nodes, dict, Node)
+ obj.instances = \
+ outils.ContainerFromDicts(obj.instances, dict, Instance)
+ obj.nodegroups = \
+ outils.ContainerFromDicts(obj.nodegroups, dict, NodeGroup)
+ obj.networks = outils.ContainerFromDicts(obj.networks, dict, Network)
return obj
def HasAnyDiskOfType(self, dev_type):
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):
@raise errors.ConfigurationError: when a parameter is not valid
"""
- if (nicparams[constants.NIC_MODE] not in constants.NIC_VALID_MODES and
- nicparams[constants.NIC_MODE] != constants.VALUE_AUTO):
- 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):
"""
if self.dev_type in [constants.LD_LV, constants.LD_FILE,
- constants.LD_BLOCKDEV, constants.LD_RBD]:
+ 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]]
"""
if self.dev_type in (constants.LD_LV, constants.LD_FILE,
- constants.LD_RBD):
+ constants.LD_RBD, constants.LD_EXT):
self.size += amount
elif self.dev_type == constants.LD_DRBD8:
if self.children:
for attr in ("children",):
alist = bo.get(attr, None)
if alist:
- bo[attr] = self._ContainerToDicts(alist)
+ bo[attr] = outils.ContainerToDicts(alist)
return bo
@classmethod
"""
obj = super(Disk, cls).FromDict(val)
if obj.children:
- obj.children = cls._ContainerFromDicts(obj.children, list, Disk)
+ obj.children = outils.ContainerFromDicts(obj.children, list, Disk)
if obj.logical_id and isinstance(obj.logical_id, list):
obj.logical_id = tuple(obj.logical_id)
if obj.physical_id and isinstance(obj.physical_id, list):
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
for attr in "nics", "disks":
alist = bo.get(attr, None)
if alist:
- nlist = self._ContainerToDicts(alist)
+ nlist = outils.ContainerToDicts(alist)
else:
nlist = []
bo[attr] = nlist
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)
+ obj.nics = outils.ContainerFromDicts(obj.nics, list, NIC)
+ obj.disks = outils.ContainerFromDicts(obj.disks, list, Disk)
return obj
def UpgradeConfig(self):
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.
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
hv_state = data.get("hv_state", None)
if hv_state is not None:
- data["hv_state"] = self._ContainerToDicts(hv_state)
+ data["hv_state"] = outils.ContainerToDicts(hv_state)
disk_state = data.get("disk_state", None)
if disk_state is not None:
data["disk_state"] = \
- dict((key, self._ContainerToDicts(value))
+ dict((key, outils.ContainerToDicts(value))
for (key, value) in disk_state.items())
return data
obj = super(Node, cls).FromDict(val)
if obj.hv_state is not None:
- obj.hv_state = cls._ContainerFromDicts(obj.hv_state, dict, NodeHvState)
+ obj.hv_state = \
+ outils.ContainerFromDicts(obj.hv_state, dict, NodeHvState)
if obj.disk_state is not None:
obj.disk_state = \
- dict((key, cls._ContainerFromDicts(value, dict, NodeDiskState))
+ dict((key, outils.ContainerFromDicts(value, dict, NodeDiskState))
for (key, value) in obj.disk_state.items())
return obj
"""
mydict = super(Cluster, self).ToDict()
- mydict["tcpudp_port_pool"] = list(self.tcpudp_port_pool)
+
+ if self.tcpudp_port_pool is None:
+ tcpudp_port_pool = []
+ else:
+ tcpudp_port_pool = list(self.tcpudp_port_pool)
+
+ mydict["tcpudp_port_pool"] = tcpudp_port_pool
+
return mydict
@classmethod
"""
obj = super(Cluster, cls).FromDict(val)
- if not isinstance(obj.tcpudp_port_pool, set):
+
+ if obj.tcpudp_port_pool is None:
+ obj.tcpudp_port_pool = set()
+ elif not isinstance(obj.tcpudp_port_pool, set):
obj.tcpudp_port_pool = set(obj.tcpudp_port_pool)
+
return obj
def SimpleFillDP(self, diskparams):
"""
mydict = super(_QueryResponseBase, self).ToDict()
- mydict["fields"] = self._ContainerToDicts(mydict["fields"])
+ mydict["fields"] = outils.ContainerToDicts(mydict["fields"])
return mydict
@classmethod
"""
obj = super(_QueryResponseBase, cls).FromDict(val)
- obj.fields = cls._ContainerFromDicts(obj.fields, list, QueryFieldDefinition)
+ obj.fields = \
+ outils.ContainerFromDicts(obj.fields, list, QueryFieldDefinition)
return obj
__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_NAME" % prefix: self.name,
+ "%sNETWORK_UUID" % prefix: self.uuid,
+ "%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
+
+ return result
+
+ @classmethod
+ def FromDict(cls, val):
+ """Custom function for networks.
+
+ Remove deprecated network_type and family.
+
+ """
+ if "network_type" in val:
+ del val["network_type"]
+ if "family" in val:
+ del val["family"]
+ obj = super(Network, cls).FromDict(val)
+ return obj
+
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)