code.grnet.gr Git - ganeti-local/blob - lib/objects.py

   1 #
   2 #
   3
   4 # Copyright (C) 2006, 2007 Google Inc.
   5 #
   6 # This program is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 2 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful, but
  12 # WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 # General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program; if not, write to the Free Software
  18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 # 02110-1301, USA.
  20
  21
  22 """Transportable objects for Ganeti.
  23
  24 This module provides small, mostly data-only objects which are safe to
  25 pass to and from external parties.
  26
  27 """
  28
  29
  30 import ConfigParser
  31 import re
  32 from cStringIO import StringIO
  33
  34 from ganeti import errors
  35 from ganeti import constants
  36
  37
  38 __all__ = ["ConfigObject", "ConfigData", "NIC", "Disk", "Instance",
  39            "OS", "Node", "Cluster"]
  40
  41
  42 class ConfigObject(object):
  43   """A generic config object.
  44
  45   It has the following properties:
  46
  47     - provides somewhat safe recursive unpickling and pickling for its classes
  48     - unset attributes which are defined in slots are always returned
  49       as None instead of raising an error
  50
  51   Classes derived from this must always declare __slots__ (we use many
  52   config objects and the memory reduction is useful.
  53
  54   """
  55   __slots__ = []
  56
  57   def __init__(self, **kwargs):
  58     for k, v in kwargs.iteritems():
  59       setattr(self, k, v)
  60
  61   def __getattr__(self, name):
  62     if name not in self.__slots__:
  63       raise AttributeError("Invalid object attribute %s.%s" %
  64                            (type(self).__name__, name))
  65     return None
  66
  67   def __setitem__(self, key, value):
  68     if key not in self.__slots__:
  69       raise KeyError(key)
  70     setattr(self, key, value)
  71
  72   def __getstate__(self):
  73     state = {}
  74     for name in self.__slots__:
  75       if hasattr(self, name):
  76         state[name] = getattr(self, name)
  77     return state
  78
  79   def __setstate__(self, state):
  80     for name in state:
  81       if name in self.__slots__:
  82         setattr(self, name, state[name])
  83
  84   def ToDict(self):
  85     """Convert to a dict holding only standard python types.
  86
  87     The generic routine just dumps all of this object's attributes in
  88     a dict. It does not work if the class has children who are
  89     ConfigObjects themselves (e.g. the nics list in an Instance), in
  90     which case the object should subclass the function in order to
  91     make sure all objects returned are only standard python types.
  92
  93     """
  94     return dict([(k, getattr(self, k, None)) for k in self.__slots__])
  95
  96   @classmethod
  97   def FromDict(cls, val):
  98     """Create an object from a dictionary.
  99
 100     This generic routine takes a dict, instantiates a new instance of
 101     the given class, and sets attributes based on the dict content.
 102
 103     As for `ToDict`, this does not work if the class has children
 104     who are ConfigObjects themselves (e.g. the nics list in an
 105     Instance), in which case the object should subclass the function
 106     and alter the objects.
 107
 108     """
 109     if not isinstance(val, dict):
 110       raise errors.ConfigurationError("Invalid object passed to FromDict:"
 111                                       " expected dict, got %s" % type(val))
 112     val_str = dict([(str(k), v) for k, v in val.iteritems()])
 113     obj = cls(**val_str)
 114     return obj
 115
 116   @staticmethod
 117   def _ContainerToDicts(container):
 118     """Convert the elements of a container to standard python types.
 119
 120     This method converts a container with elements derived from
 121     ConfigData to standard python types. If the container is a dict,
 122     we don't touch the keys, only the values.
 123
 124     """
 125     if isinstance(container, dict):
 126       ret = dict([(k, v.ToDict()) for k, v in container.iteritems()])
 127     elif isinstance(container, (list, tuple, set, frozenset)):
 128       ret = [elem.ToDict() for elem in container]
 129     else:
 130       raise TypeError("Invalid type %s passed to _ContainerToDicts" %
 131                       type(container))
 132     return ret
 133
 134   @staticmethod
 135   def _ContainerFromDicts(source, c_type, e_type):
 136     """Convert a container from standard python types.
 137
 138     This method converts a container with standard python types to
 139     ConfigData objects. If the container is a dict, we don't touch the
 140     keys, only the values.
 141
 142     """
 143     if not isinstance(c_type, type):
 144       raise TypeError("Container type %s passed to _ContainerFromDicts is"
 145                       " not a type" % type(c_type))
 146     if c_type is dict:
 147       ret = dict([(k, e_type.FromDict(v)) for k, v in source.iteritems()])
 148     elif c_type in (list, tuple, set, frozenset):
 149       ret = c_type([e_type.FromDict(elem) for elem in source])
 150     else:
 151       raise TypeError("Invalid container type %s passed to"
 152                       " _ContainerFromDicts" % c_type)
 153     return ret
 154
 155   def __repr__(self):
 156     """Implement __repr__ for ConfigObjects."""
 157     return repr(self.ToDict())
 158
 159
 160 class TaggableObject(ConfigObject):
 161   """An generic class supporting tags.
 162
 163   """
 164   __slots__ = ConfigObject.__slots__ + ["tags"]
 165
 166   @staticmethod
 167   def ValidateTag(tag):
 168     """Check if a tag is valid.
 169
 170     If the tag is invalid, an errors.TagError will be raised. The
 171     function has no return value.
 172
 173     """
 174     if not isinstance(tag, basestring):
 175       raise errors.TagError("Invalid tag type (not a string)")
 176     if len(tag) > constants.MAX_TAG_LEN:
 177       raise errors.TagError("Tag too long (>%d characters)" %
 178                             constants.MAX_TAG_LEN)
 179     if not tag:
 180       raise errors.TagError("Tags cannot be empty")
 181     if not re.match("^[ \w.+*/:-]+$", tag):
 182       raise errors.TagError("Tag contains invalid characters")
 183
 184   def GetTags(self):
 185     """Return the tags list.
 186
 187     """
 188     tags = getattr(self, "tags", None)
 189     if tags is None:
 190       tags = self.tags = set()
 191     return tags
 192
 193   def AddTag(self, tag):
 194     """Add a new tag.
 195
 196     """
 197     self.ValidateTag(tag)
 198     tags = self.GetTags()
 199     if len(tags) >= constants.MAX_TAGS_PER_OBJ:
 200       raise errors.TagError("Too many tags")
 201     self.GetTags().add(tag)
 202
 203   def RemoveTag(self, tag):
 204     """Remove a tag.
 205
 206     """
 207     self.ValidateTag(tag)
 208     tags = self.GetTags()
 209     try:
 210       tags.remove(tag)
 211     except KeyError:
 212       raise errors.TagError("Tag not found")
 213
 214   def ToDict(self):
 215     """Taggable-object-specific conversion to standard python types.
 216
 217     This replaces the tags set with a list.
 218
 219     """
 220     bo = super(TaggableObject, self).ToDict()
 221
 222     tags = bo.get("tags", None)
 223     if isinstance(tags, set):
 224       bo["tags"] = list(tags)
 225     return bo
 226
 227   @classmethod
 228   def FromDict(cls, val):
 229     """Custom function for instances.
 230
 231     """
 232     obj = super(TaggableObject, cls).FromDict(val)
 233     if hasattr(obj, "tags") and isinstance(obj.tags, list):
 234       obj.tags = set(obj.tags)
 235     return obj
 236
 237
 238 class ConfigData(ConfigObject):
 239   """Top-level config object."""
 240   __slots__ = ["cluster", "nodes", "instances"]
 241
 242   def ToDict(self):
 243     """Custom function for top-level config data.
 244
 245     This just replaces the list of instances, nodes and the cluster
 246     with standard python types.
 247
 248     """
 249     mydict = super(ConfigData, self).ToDict()
 250     mydict["cluster"] = mydict["cluster"].ToDict()
 251     for key in "nodes", "instances":
 252       mydict[key] = self._ContainerToDicts(mydict[key])
 253
 254     return mydict
 255
 256   @classmethod
 257   def FromDict(cls, val):
 258     """Custom function for top-level config data
 259
 260     """
 261     obj = super(ConfigData, cls).FromDict(val)
 262     obj.cluster = Cluster.FromDict(obj.cluster)
 263     obj.nodes = cls._ContainerFromDicts(obj.nodes, dict, Node)
 264     obj.instances = cls._ContainerFromDicts(obj.instances, dict, Instance)
 265     return obj
 266
 267
 268 class NIC(ConfigObject):
 269   """Config object representing a network card."""
 270   __slots__ = ["mac", "ip", "bridge"]
 271
 272
 273 class Disk(ConfigObject):
 274   """Config object representing a block device."""
 275   __slots__ = ["dev_type", "logical_id", "physical_id",
 276                "children", "iv_name", "size"]
 277
 278   def CreateOnSecondary(self):
 279     """Test if this device needs to be created on a secondary node."""
 280     return self.dev_type in (constants.LD_DRBD7, constants.LD_DRBD8,
 281                              constants.LD_LV)
 282
 283   def AssembleOnSecondary(self):
 284     """Test if this device needs to be assembled on a secondary node."""
 285     return self.dev_type in (constants.LD_DRBD7, constants.LD_DRBD8,
 286                              constants.LD_LV)
 287
 288   def OpenOnSecondary(self):
 289     """Test if this device needs to be opened on a secondary node."""
 290     return self.dev_type in (constants.LD_LV,)
 291
 292   def StaticDevPath(self):
 293     """Return the device path if this device type has a static one.
 294
 295     Some devices (LVM for example) live always at the same /dev/ path,
 296     irrespective of their status. For such devices, we return this
 297     path, for others we return None.
 298
 299     """
 300     if self.dev_type == constants.LD_LV:
 301       return "/dev/%s/%s" % (self.logical_id[0], self.logical_id[1])
 302     return None
 303
 304   def ChildrenNeeded(self):
 305     """Compute the needed number of children for activation.
 306
 307     This method will return either -1 (all children) or a positive
 308     number denoting the minimum number of children needed for
 309     activation (only mirrored devices will usually return >=0).
 310
 311     Currently, only DRBD8 supports diskless activation (therefore we
 312     return 0), for all other we keep the previous semantics and return
 313     -1.
 314
 315     """
 316     if self.dev_type == constants.LD_DRBD8:
 317       return 0
 318     return -1
 319
 320   def GetNodes(self, node):
 321     """This function returns the nodes this device lives on.
 322
 323     Given the node on which the parent of the device lives on (or, in
 324     case of a top-level device, the primary node of the devices'
 325     instance), this function will return a list of nodes on which this
 326     devices needs to (or can) be assembled.
 327
 328     """
 329     if self.dev_type == constants.LD_LV or self.dev_type == constants.LD_MD_R1:
 330       result = [node]
 331     elif self.dev_type in constants.LDS_DRBD:
 332       result = [self.logical_id[0], self.logical_id[1]]
 333       if node not in result:
 334         raise errors.ConfigurationError("DRBD device passed unknown node")
 335     else:
 336       raise errors.ProgrammerError("Unhandled device type %s" % self.dev_type)
 337     return result
 338
 339   def ComputeNodeTree(self, parent_node):
 340     """Compute the node/disk tree for this disk and its children.
 341
 342     This method, given the node on which the parent disk lives, will
 343     return the list of all (node, disk) pairs which describe the disk
 344     tree in the most compact way. For example, a md/drbd/lvm stack
 345     will be returned as (primary_node, md) and (secondary_node, drbd)
 346     which represents all the top-level devices on the nodes. This
 347     means that on the primary node we need to activate the the md (and
 348     recursively all its children) and on the secondary node we need to
 349     activate the drbd device (and its children, the two lvm volumes).
 350
 351     """
 352     my_nodes = self.GetNodes(parent_node)
 353     result = [(node, self) for node in my_nodes]
 354     if not self.children:
 355       # leaf device
 356       return result
 357     for node in my_nodes:
 358       for child in self.children:
 359         child_result = child.ComputeNodeTree(node)
 360         if len(child_result) == 1:
 361           # child (and all its descendants) is simple, doesn't split
 362           # over multiple hosts, so we don't need to describe it, our
 363           # own entry for this node describes it completely
 364           continue
 365         else:
 366           # check if child nodes differ from my nodes; note that
 367           # subdisk can differ from the child itself, and be instead
 368           # one of its descendants
 369           for subnode, subdisk in child_result:
 370             if subnode not in my_nodes:
 371               result.append((subnode, subdisk))
 372             # otherwise child is under our own node, so we ignore this
 373             # entry (but probably the other results in the list will
 374             # be different)
 375     return result
 376
 377   def ToDict(self):
 378     """Disk-specific conversion to standard python types.
 379
 380     This replaces the children lists of objects with lists of
 381     standard python types.
 382
 383     """
 384     bo = super(Disk, self).ToDict()
 385
 386     for attr in ("children",):
 387       alist = bo.get(attr, None)
 388       if alist:
 389         bo[attr] = self._ContainerToDicts(alist)
 390     return bo
 391
 392   @classmethod
 393   def FromDict(cls, val):
 394     """Custom function for Disks
 395
 396     """
 397     obj = super(Disk, cls).FromDict(val)
 398     if obj.children:
 399       obj.children = cls._ContainerFromDicts(obj.children, list, Disk)
 400     if obj.logical_id and isinstance(obj.logical_id, list):
 401       obj.logical_id = tuple(obj.logical_id)
 402     if obj.physical_id and isinstance(obj.physical_id, list):
 403       obj.physical_id = tuple(obj.physical_id)
 404     return obj
 405
 406   def __str__(self):
 407     """Custom str() formatter for disks.
 408
 409     """
 410     if self.dev_type == constants.LD_LV:
 411       val =  "<LogicalVolume(/dev/%s/%s" % self.logical_id
 412     elif self.dev_type in constants.LDS_DRBD:
 413       if self.dev_type == constants.LD_DRBD7:
 414         val = "<DRBD7("
 415       else:
 416         val = "<DRBD8("
 417       if self.physical_id is None:
 418         phy = "unconfigured"
 419       else:
 420         phy = ("configured as %s:%s %s:%s" %
 421                (self.physical_id[0], self.physical_id[1],
 422                 self.physical_id[2], self.physical_id[3]))
 423
 424       val += ("hosts=%s-%s, port=%s, %s, " %
 425               (self.logical_id[0], self.logical_id[1], self.logical_id[2],
 426                phy))
 427       if self.children and self.children.count(None) == 0:
 428         val += "backend=%s, metadev=%s" % (self.children[0], self.children[1])
 429       else:
 430         val += "no local storage"
 431     elif self.dev_type == constants.LD_MD_R1:
 432       val = "<MD_R1(uuid=%s, children=%s" % (self.physical_id, self.children)
 433     else:
 434       val = ("<Disk(type=%s, logical_id=%s, physical_id=%s, children=%s" %
 435              (self.dev_type, self.logical_id, self.physical_id, self.children))
 436     if self.iv_name is None:
 437       val += ", not visible"
 438     else:
 439       val += ", visible as /dev/%s" % self.iv_name
 440     val += ", size=%dm)>" % self.size
 441     return val
 442
 443
 444 class Instance(TaggableObject):
 445   """Config object representing an instance."""
 446   __slots__ = TaggableObject.__slots__ + [
 447     "name",
 448     "primary_node",
 449     "os",
 450     "status",
 451     "memory",
 452     "vcpus",
 453     "nics",
 454     "disks",
 455     "disk_template",
 456     "network_port",
 457     "kernel_path",
 458     "initrd_path",
 459     "hvm_boot_order",
 460     "hvm_acpi",
 461     "hvm_pae",
 462     "hvm_cdrom_image_path",
 463     "vnc_bind_address",
 464     ]
 465
 466   def _ComputeSecondaryNodes(self):
 467     """Compute the list of secondary nodes.
 468
 469     Since the data is already there (in the drbd disks), keeping it as
 470     a separate normal attribute is redundant and if not properly
 471     synchronised can cause problems. Thus it's better to compute it
 472     dynamically.
 473
 474     """
 475     def _Helper(primary, sec_nodes, device):
 476       """Recursively computes secondary nodes given a top device."""
 477       if device.dev_type in constants.LDS_DRBD:
 478         nodea, nodeb, dummy = device.logical_id
 479         if nodea == primary:
 480           candidate = nodeb
 481         else:
 482           candidate = nodea
 483         if candidate not in sec_nodes:
 484           sec_nodes.append(candidate)
 485       if device.children:
 486         for child in device.children:
 487           _Helper(primary, sec_nodes, child)
 488
 489     secondary_nodes = []
 490     for device in self.disks:
 491       _Helper(self.primary_node, secondary_nodes, device)
 492     return tuple(secondary_nodes)
 493
 494   secondary_nodes = property(_ComputeSecondaryNodes, None, None,
 495                              "List of secondary nodes")
 496
 497   def MapLVsByNode(self, lvmap=None, devs=None, node=None):
 498     """Provide a mapping of nodes to LVs this instance owns.
 499
 500     This function figures out what logical volumes should belong on which
 501     nodes, recursing through a device tree.
 502
 503     Args:
 504       lvmap: (optional) a dictionary to receive the 'node' : ['lv', ...] data.
 505
 506     Returns:
 507       None if lvmap arg is given.
 508       Otherwise, { 'nodename' : ['volume1', 'volume2', ...], ... }
 509
 510     """
 511     if node == None:
 512       node = self.primary_node
 513
 514     if lvmap is None:
 515       lvmap = { node : [] }
 516       ret = lvmap
 517     else:
 518       if not node in lvmap:
 519         lvmap[node] = []
 520       ret = None
 521
 522     if not devs:
 523       devs = self.disks
 524
 525     for dev in devs:
 526       if dev.dev_type == constants.LD_LV:
 527         lvmap[node].append(dev.logical_id[1])
 528
 529       elif dev.dev_type in constants.LDS_DRBD:
 530         if dev.logical_id[0] not in lvmap:
 531           lvmap[dev.logical_id[0]] = []
 532
 533         if dev.logical_id[1] not in lvmap:
 534           lvmap[dev.logical_id[1]] = []
 535
 536         if dev.children:
 537           self.MapLVsByNode(lvmap, dev.children, dev.logical_id[0])
 538           self.MapLVsByNode(lvmap, dev.children, dev.logical_id[1])
 539
 540       elif dev.children:
 541         self.MapLVsByNode(lvmap, dev.children, node)
 542
 543     return ret
 544
 545   def FindDisk(self, name):
 546     """Find a disk given having a specified name.
 547
 548     This will return the disk which has the given iv_name.
 549
 550     """
 551     for disk in self.disks:
 552       if disk.iv_name == name:
 553         return disk
 554
 555     return None
 556
 557   def ToDict(self):
 558     """Instance-specific conversion to standard python types.
 559
 560     This replaces the children lists of objects with lists of standard
 561     python types.
 562
 563     """
 564     bo = super(Instance, self).ToDict()
 565
 566     for attr in "nics", "disks":
 567       alist = bo.get(attr, None)
 568       if alist:
 569         nlist = self._ContainerToDicts(alist)
 570       else:
 571         nlist = []
 572       bo[attr] = nlist
 573     return bo
 574
 575   @classmethod
 576   def FromDict(cls, val):
 577     """Custom function for instances.
 578
 579     """
 580     obj = super(Instance, cls).FromDict(val)
 581     obj.nics = cls._ContainerFromDicts(obj.nics, list, NIC)
 582     obj.disks = cls._ContainerFromDicts(obj.disks, list, Disk)
 583     return obj
 584
 585
 586 class OS(ConfigObject):
 587   """Config object representing an operating system."""
 588   __slots__ = [
 589     "name",
 590     "path",
 591     "status",
 592     "api_version",
 593     "create_script",
 594     "export_script",
 595     "import_script",
 596     "rename_script",
 597     ]
 598
 599   @classmethod
 600   def FromInvalidOS(cls, err):
 601     """Create an OS from an InvalidOS error.
 602
 603     This routine knows how to convert an InvalidOS error to an OS
 604     object representing the broken OS with a meaningful error message.
 605
 606     """
 607     if not isinstance(err, errors.InvalidOS):
 608       raise errors.ProgrammerError("Trying to initialize an OS from an"
 609                                    " invalid object of type %s" % type(err))
 610
 611     return cls(name=err.args[0], path=err.args[1], status=err.args[2])
 612
 613   def __nonzero__(self):
 614     return self.status == constants.OS_VALID_STATUS
 615
 616   __bool__ = __nonzero__
 617
 618 class Node(TaggableObject):
 619   """Config object representing a node."""
 620   __slots__ = TaggableObject.__slots__ + [
 621     "name",
 622     "primary_ip",
 623     "secondary_ip",
 624     ]
 625
 626
 627 class Cluster(TaggableObject):
 628   """Config object representing the cluster."""
 629   __slots__ = TaggableObject.__slots__ + [
 630     "config_version",
 631     "serial_no",
 632     "rsahostkeypub",
 633     "highest_used_port",
 634     "tcpudp_port_pool",
 635     "mac_prefix",
 636     "volume_group_name",
 637     "default_bridge",
 638     ]
 639
 640   def ToDict(self):
 641     """Custom function for cluster.
 642
 643     """
 644     mydict = super(Cluster, self).ToDict()
 645     mydict["tcpudp_port_pool"] = list(self.tcpudp_port_pool)
 646     return mydict
 647
 648   @classmethod
 649   def FromDict(cls, val):
 650     """Custom function for cluster.
 651
 652     """
 653     obj = super(Cluster, cls).FromDict(val)
 654     if not isinstance(obj.tcpudp_port_pool, set):
 655       obj.tcpudp_port_pool = set(obj.tcpudp_port_pool)
 656     return obj
 657
 658
 659 class SerializableConfigParser(ConfigParser.SafeConfigParser):
 660   """Simple wrapper over ConfigParse that allows serialization.
 661
 662   This class is basically ConfigParser.SafeConfigParser with two
 663   additional methods that allow it to serialize/unserialize to/from a
 664   buffer.
 665
 666   """
 667   def Dumps(self):
 668     """Dump this instance and return the string representation."""
 669     buf = StringIO()
 670     self.write(buf)
 671     return buf.getvalue()
 672
 673   @staticmethod
 674   def Loads(data):
 675     """Load data from a string."""
 676     buf = StringIO(data)
 677     cfp = SerializableConfigParser()
 678     cfp.readfp(buf)
 679     return cfp