X-Git-Url: https://code.grnet.gr/git/ganeti-local/blobdiff_plain/d2c807e4c2bb353343485eb14a143e19f828c653..97efde459ccd6770faab6c2a81db7a9ee60104d3:/lib/objects.py?ds=sidebyside diff --git a/lib/objects.py b/lib/objects.py index c5e7f4a..522162a 100644 --- a/lib/objects.py +++ b/lib/objects.py @@ -27,7 +27,6 @@ pass to and from external parties. """ -import simplejson import ConfigParser import re from cStringIO import StringIO @@ -40,14 +39,6 @@ __all__ = ["ConfigObject", "ConfigData", "NIC", "Disk", "Instance", "OS", "Node", "Cluster"] -# Check whether the simplejson module supports indentation -_JSON_INDENT = 2 -try: - simplejson.dumps(1, indent=_JSON_INDENT) -except TypeError: - _JSON_INDENT = None - - class ConfigObject(object): """A generic config object. @@ -90,34 +81,6 @@ class ConfigObject(object): if name in self.__slots__: setattr(self, name, state[name]) - def Dump(self, fobj): - """Dump to a file object. - - """ - data = self.ToDict() - if _JSON_INDENT is None: - simplejson.dump(data, fobj) - else: - simplejson.dump(data, fobj, indent=_JSON_INDENT) - - @classmethod - def Load(cls, fobj): - """Load data from the given stream. - - """ - return cls.FromDict(simplejson.load(fobj)) - - def Dumps(self): - """Dump and return the string representation.""" - buf = StringIO() - self.Dump(buf) - return buf.getvalue() - - @classmethod - def Loads(cls, data): - """Load data from a string.""" - return cls.Load(StringIO(data)) - def ToDict(self): """Convert to a dict holding only standard python types. @@ -314,18 +277,44 @@ class Disk(ConfigObject): 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.""" return self.dev_type in (constants.LD_LV,) + def StaticDevPath(self): + """Return the device path if this device type has a static one. + + Some devices (LVM for example) live always at the same /dev/ path, + irrespective of their status. For such devices, we return this + path, for others we return None. + + """ + if self.dev_type == constants.LD_LV: + return "/dev/%s/%s" % (self.logical_id[0], self.logical_id[1]) + return None + + def ChildrenNeeded(self): + """Compute the needed number of children for activation. + + This method will return either -1 (all children) or a positive + number denoting the minimum number of children needed for + activation (only mirrored devices will usually return >=0). + + Currently, only DRBD8 supports diskless activation (therefore we + return 0), for all other we keep the previous semantics and return + -1. + + """ + if self.dev_type == constants.LD_DRBD8: + return 0 + return -1 + def GetNodes(self, node): """This function returns the nodes this device lives on. @@ -335,7 +324,7 @@ class Disk(ConfigObject): devices needs to (or can) be assembled. """ - if self.dev_type == constants.LD_LV or self.dev_type == constants.LD_MD_R1: + 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]] @@ -350,12 +339,9 @@ class Disk(ConfigObject): This method, given the node on which the parent disk lives, will return the list of all (node, disk) pairs which describe the disk - tree in the most compact way. For example, a md/drbd/lvm stack - will be returned as (primary_node, md) and (secondary_node, drbd) - which represents all the top-level devices on the nodes. This - means that on the primary node we need to activate the the md (and - recursively all its children) and on the secondary node we need to - activate the drbd device (and its children, the two lvm volumes). + tree in the most compact way. For example, a drbd/lvm stack + will be returned as (primary_node, drbd) and (secondary_node, drbd) + which represents all the top-level devices on the nodes. """ my_nodes = self.GetNodes(parent_node) @@ -383,6 +369,68 @@ class Disk(ConfigObject): # be different) return result + def RecordGrow(self, amount): + """Update the size of this disk after growth. + + This method recurses over the disks's children and updates their + size correspondigly. The method needs to be kept in sync with the + actual algorithms from bdev. + + """ + if self.dev_type == constants.LD_LV: + self.size += amount + elif self.dev_type == constants.LD_DRBD8: + if self.children: + self.children[0].RecordGrow(amount) + self.size += amount + else: + raise errors.ProgrammerError("Disk.RecordGrow called for unsupported" + " disk type %s" % self.dev_type) + + def SetPhysicalID(self, target_node, nodes_ip): + """Convert the logical ID to the physical ID. + + 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. + + Arguments: + - target_node: the node we wish to configure for + - nodes_ip: a mapping of node name to ip + + The target_node must exist in in nodes_ip, and must be one of the + nodes in the logical ID for each of the DRBD devices encountered + in the disk tree. + + """ + if self.children: + for child in self.children: + child.SetPhysicalID(target_node, nodes_ip) + + 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 + if target_node not in (pnode, snode): + raise errors.ConfigurationError("DRBD device not knowing node %s" % + target_node) + pnode_ip = nodes_ip.get(pnode, None) + snode_ip = nodes_ip.get(snode, None) + if pnode_ip is None or snode_ip is None: + raise errors.ConfigurationError("Can't find primary or secondary node" + " for %s" % str(self)) + if pnode == target_node: + self.physical_id = (pnode_ip, port, + snode_ip, port) + else: # it must be secondary, we tested above + self.physical_id = (snode_ip, port, + pnode_ip, port) + else: + self.physical_id = self.logical_id + return + def ToDict(self): """Disk-specific conversion to standard python types. @@ -419,10 +467,7 @@ class Disk(ConfigObject): if self.dev_type == constants.LD_LV: val = "