X-Git-Url: https://code.grnet.gr/git/ganeti-local/blobdiff_plain/319856a9ed410d3dd6493c837a3781176406e9ce..785d79f724265675b86cb76959b757d553d077e5:/lib/objects.py

diff --git a/lib/objects.py b/lib/objects.py
index f85de16..fc3ed09 100644
--- a/lib/objects.py
+++ b/lib/objects.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#
 #
 
 # Copyright (C) 2006, 2007 Google Inc.
@@ -27,10 +27,9 @@ pass to and from external parties.
 """
 
 
-import simplejson
-from cStringIO import StringIO
 import ConfigParser
 import re
+from cStringIO import StringIO
 
 from ganeti import errors
 from ganeti import constants
@@ -82,30 +81,6 @@ class ConfigObject(object):
       if name in self.__slots__:
         setattr(self, name, state[name])
 
-  def Dump(self, fobj):
-    """Dump to a file object.
-
-    """
-    simplejson.dump(self.ToDict(), fobj)
-
-  @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.
 
@@ -189,15 +164,21 @@ class TaggableObject(ConfigObject):
   __slots__ = ConfigObject.__slots__ + ["tags"]
 
   @staticmethod
-  def ValidateTag(tag):
+  def ValidateTag(tag, removal=False):
     """Check if a tag is valid.
 
     If the tag is invalid, an errors.TagError will be raised. The
     function has no return value.
 
+    Args:
+      tag: Tag value
+      removal: Validating tag for removal?
+
     """
     if not isinstance(tag, basestring):
       raise errors.TagError("Invalid tag type (not a string)")
+    if removal:
+      return
     if len(tag) > constants.MAX_TAG_LEN:
       raise errors.TagError("Tag too long (>%d characters)" %
                             constants.MAX_TAG_LEN)
@@ -229,7 +210,7 @@ class TaggableObject(ConfigObject):
     """Remove a tag.
 
     """
-    self.ValidateTag(tag)
+    self.ValidateTag(tag, removal=True)
     tags = self.GetTags()
     try:
       tags.remove(tag)
@@ -302,15 +283,45 @@ class Disk(ConfigObject):
 
   def CreateOnSecondary(self):
     """Test if this device needs to be created on a secondary node."""
-    return self.dev_type in ("drbd", "lvm")
+    return self.dev_type in (constants.LD_DRBD7, 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 ("drbd", "lvm")
+    return self.dev_type in (constants.LD_DRBD7, 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 ("lvm",)
+    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.
@@ -321,9 +332,9 @@ class Disk(ConfigObject):
     devices needs to (or can) be assembled.
 
     """
-    if self.dev_type == "lvm" or self.dev_type == "md_raid1":
+    if self.dev_type == constants.LD_LV or self.dev_type == constants.LD_MD_R1:
       result = [node]
-    elif self.dev_type == "drbd":
+    elif self.dev_type in constants.LDS_DRBD:
       result = [self.logical_id[0], self.logical_id[1]]
       if node not in result:
         raise errors.ConfigurationError("DRBD device passed unknown node")
@@ -369,6 +380,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.
 
@@ -398,6 +471,43 @@ class Disk(ConfigObject):
       obj.physical_id = tuple(obj.physical_id)
     return obj
 
+  def __str__(self):
+    """Custom str() formatter for disks.
+
+    """
+    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("
+      if self.physical_id is None:
+        phy = "unconfigured"
+      else:
+        phy = ("configured as %s:%s %s:%s" %
+               (self.physical_id[0], self.physical_id[1],
+                self.physical_id[2], self.physical_id[3]))
+
+      val += ("hosts=%s-%s, port=%s, %s, " %
+              (self.logical_id[0], self.logical_id[1], self.logical_id[2],
+               phy))
+      if self.children and self.children.count(None) == 0:
+        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))
+    if self.iv_name is None:
+      val += ", not visible"
+    else:
+      val += ", visible as /dev/%s" % self.iv_name
+    val += ", size=%dm)>" % self.size
+    return val
+
 
 class Instance(TaggableObject):
   """Config object representing an instance."""
@@ -411,6 +521,17 @@ class Instance(TaggableObject):
     "nics",
     "disks",
     "disk_template",
+    "network_port",
+    "kernel_path",
+    "initrd_path",
+    "hvm_boot_order",
+    "hvm_acpi",
+    "hvm_pae",
+    "hvm_cdrom_image_path",
+    "hvm_nic_type",
+    "hvm_disk_type",
+    "vnc_bind_address",
+    "auto_balance",
     ]
 
   def _ComputeSecondaryNodes(self):
@@ -424,7 +545,7 @@ class Instance(TaggableObject):
     """
     def _Helper(primary, sec_nodes, device):
       """Recursively computes secondary nodes given a top device."""
-      if device.dev_type == 'drbd':
+      if device.dev_type in constants.LDS_DRBD:
         nodea, nodeb, dummy = device.logical_id
         if nodea == primary:
           candidate = nodeb
@@ -473,10 +594,10 @@ class Instance(TaggableObject):
       devs = self.disks
 
     for dev in devs:
-      if dev.dev_type == "lvm":
+      if dev.dev_type == constants.LD_LV:
         lvmap[node].append(dev.logical_id[1])
 
-      elif dev.dev_type == "drbd":
+      elif dev.dev_type in constants.LDS_DRBD:
         if dev.logical_id[0] not in lvmap:
           lvmap[dev.logical_id[0]] = []
 
@@ -527,6 +648,9 @@ class Instance(TaggableObject):
     """Custom function for instances.
 
     """
+    # we set the auto_balance value to True if missing
+    if val.get("auto_balance", None) is None:
+      val["auto_balance"] = True
     obj = super(Instance, cls).FromDict(val)
     obj.nics = cls._ContainerFromDicts(obj.nics, list, NIC)
     obj.disks = cls._ContainerFromDicts(obj.disks, list, Disk)
@@ -538,13 +662,32 @@ class OS(ConfigObject):
   __slots__ = [
     "name",
     "path",
-    "api_version",
+    "status",
+    "api_versions",
     "create_script",
     "export_script",
     "import_script",
     "rename_script",
     ]
 
+  @classmethod
+  def FromInvalidOS(cls, err):
+    """Create an OS from an InvalidOS error.
+
+    This routine knows how to convert an InvalidOS error to an OS
+    object representing the broken OS with a meaningful error message.
+
+    """
+    if not isinstance(err, errors.InvalidOS):
+      raise errors.ProgrammerError("Trying to initialize an OS from an"
+                                   " invalid object of type %s" % type(err))
+
+    return cls(name=err.args[0], path=err.args[1], status=err.args[2])
+
+  def __nonzero__(self):
+    return self.status == constants.OS_VALID_STATUS
+
+  __bool__ = __nonzero__
 
 class Node(TaggableObject):
   """Config object representing a node."""
@@ -572,7 +715,7 @@ class Cluster(TaggableObject):
     """Custom function for cluster.
 
     """
-    mydict = super(TaggableObject, self).ToDict()
+    mydict = super(Cluster, self).ToDict()
     mydict["tcpudp_port_pool"] = list(self.tcpudp_port_pool)
     return mydict
 
@@ -581,7 +724,7 @@ class Cluster(TaggableObject):
     """Custom function for cluster.
 
     """
-    obj = super(TaggableObject, cls).FromDict(val)
+    obj = super(Cluster, cls).FromDict(val)
     if not isinstance(obj.tcpudp_port_pool, set):
       obj.tcpudp_port_pool = set(obj.tcpudp_port_pool)
     return obj