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_DRBD8, constants.LD_LV)
 281
 282   def AssembleOnSecondary(self):
 283     """Test if this device needs to be assembled on a secondary node."""
 284     return self.dev_type in (constants.LD_DRBD8, constants.LD_LV)
 285
 286   def OpenOnSecondary(self):
 287     """Test if this device needs to be opened on a secondary node."""
 288     return self.dev_type in (constants.LD_LV,)
 289
 290   def StaticDevPath(self):
 291     """Return the device path if this device type has a static one.
 292
 293     Some devices (LVM for example) live always at the same /dev/ path,
 294     irrespective of their status. For such devices, we return this
 295     path, for others we return None.
 296
 297     """
 298     if self.dev_type == constants.LD_LV:
 299       return "/dev/%s/%s" % (self.logical_id[0], self.logical_id[1])
 300     return None
 301
 302   def ChildrenNeeded(self):
 303     """Compute the needed number of children for activation.
 304
 305     This method will return either -1 (all children) or a positive
 306     number denoting the minimum number of children needed for
 307     activation (only mirrored devices will usually return >=0).
 308
 309     Currently, only DRBD8 supports diskless activation (therefore we
 310     return 0), for all other we keep the previous semantics and return
 311     -1.
 312
 313     """
 314     if self.dev_type == constants.LD_DRBD8:
 315       return 0
 316     return -1
 317
 318   def GetNodes(self, node):
 319     """This function returns the nodes this device lives on.
 320
 321     Given the node on which the parent of the device lives on (or, in
 322     case of a top-level device, the primary node of the devices'
 323     instance), this function will return a list of nodes on which this
 324     devices needs to (or can) be assembled.
 325
 326     """
 327     if self.dev_type in [constants.LD_LV, constants.LD_FILE]:
 328       result = [node]
 329     elif self.dev_type in constants.LDS_DRBD:
 330       result = [self.logical_id[0], self.logical_id[1]]
 331       if node not in result:
 332         raise errors.ConfigurationError("DRBD device passed unknown node")
 333     else:
 334       raise errors.ProgrammerError("Unhandled device type %s" % self.dev_type)
 335     return result
 336
 337   def ComputeNodeTree(self, parent_node):
 338     """Compute the node/disk tree for this disk and its children.
 339
 340     This method, given the node on which the parent disk lives, will
 341     return the list of all (node, disk) pairs which describe the disk
 342     tree in the most compact way. For example, a drbd/lvm stack
 343     will be returned as (primary_node, drbd) and (secondary_node, drbd)
 344     which represents all the top-level devices on the nodes.
 345
 346     """
 347     my_nodes = self.GetNodes(parent_node)
 348     result = [(node, self) for node in my_nodes]
 349     if not self.children:
 350       # leaf device
 351       return result
 352     for node in my_nodes:
 353       for child in self.children:
 354         child_result = child.ComputeNodeTree(node)
 355         if len(child_result) == 1:
 356           # child (and all its descendants) is simple, doesn't split
 357           # over multiple hosts, so we don't need to describe it, our
 358           # own entry for this node describes it completely
 359           continue
 360         else:
 361           # check if child nodes differ from my nodes; note that
 362           # subdisk can differ from the child itself, and be instead
 363           # one of its descendants
 364           for subnode, subdisk in child_result:
 365             if subnode not in my_nodes:
 366               result.append((subnode, subdisk))
 367             # otherwise child is under our own node, so we ignore this
 368             # entry (but probably the other results in the list will
 369             # be different)
 370     return result
 371
 372   def RecordGrow(self, amount):
 373     """Update the size of this disk after growth.
 374
 375     This method recurses over the disks's children and updates their
 376     size correspondigly. The method needs to be kept in sync with the
 377     actual algorithms from bdev.
 378
 379     """
 380     if self.dev_type == constants.LD_LV:
 381       self.size += amount
 382     elif self.dev_type == constants.LD_DRBD8:
 383       if self.children:
 384         self.children[0].RecordGrow(amount)
 385       self.size += amount
 386     else:
 387       raise errors.ProgrammerError("Disk.RecordGrow called for unsupported"
 388                                    " disk type %s" % self.dev_type)
 389
 390   def SetPhysicalID(self, target_node, nodes_ip):
 391     """Convert the logical ID to the physical ID.
 392
 393     This is used only for drbd, which needs ip/port configuration.
 394
 395     The routine descends down and updates its children also, because
 396     this helps when the only the top device is passed to the remote
 397     node.
 398
 399     Arguments:
 400       - target_node: the node we wish to configure for
 401       - nodes_ip: a mapping of node name to ip
 402
 403     The target_node must exist in in nodes_ip, and must be one of the
 404     nodes in the logical ID for each of the DRBD devices encountered
 405     in the disk tree.
 406
 407     """
 408     if self.children:
 409       for child in self.children:
 410         child.SetPhysicalID(target_node, nodes_ip)
 411
 412     if self.logical_id is None and self.physical_id is not None:
 413       return
 414     if self.dev_type in constants.LDS_DRBD:
 415       pnode, snode, port = self.logical_id
 416       if target_node not in (pnode, snode):
 417         raise errors.ConfigurationError("DRBD device not knowing node %s" %
 418                                         target_node)
 419       pnode_ip = nodes_ip.get(pnode, None)
 420       snode_ip = nodes_ip.get(snode, None)
 421       if pnode_ip is None or snode_ip is None:
 422         raise errors.ConfigurationError("Can't find primary or secondary node"
 423                                         " for %s" % str(self))
 424       if pnode == target_node:
 425         self.physical_id = (pnode_ip, port,
 426                             snode_ip, port)
 427       else: # it must be secondary, we tested above
 428         self.physical_id = (snode_ip, port,
 429                             pnode_ip, port)
 430     else:
 431       self.physical_id = self.logical_id
 432     return
 433
 434   def ToDict(self):
 435     """Disk-specific conversion to standard python types.
 436
 437     This replaces the children lists of objects with lists of
 438     standard python types.
 439
 440     """
 441     bo = super(Disk, self).ToDict()
 442
 443     for attr in ("children",):
 444       alist = bo.get(attr, None)
 445       if alist:
 446         bo[attr] = self._ContainerToDicts(alist)
 447     return bo
 448
 449   @classmethod
 450   def FromDict(cls, val):
 451     """Custom function for Disks
 452
 453     """
 454     obj = super(Disk, cls).FromDict(val)
 455     if obj.children:
 456       obj.children = cls._ContainerFromDicts(obj.children, list, Disk)
 457     if obj.logical_id and isinstance(obj.logical_id, list):
 458       obj.logical_id = tuple(obj.logical_id)
 459     if obj.physical_id and isinstance(obj.physical_id, list):
 460       obj.physical_id = tuple(obj.physical_id)
 461     return obj
 462
 463   def __str__(self):
 464     """Custom str() formatter for disks.
 465
 466     """
 467     if self.dev_type == constants.LD_LV:
 468       val =  "<LogicalVolume(/dev/%s/%s" % self.logical_id
 469     elif self.dev_type in constants.LDS_DRBD:
 470       val = "<DRBD8("
 471       if self.physical_id is None:
 472         phy = "unconfigured"
 473       else:
 474         phy = ("configured as %s:%s %s:%s" %
 475                (self.physical_id[0], self.physical_id[1],
 476                 self.physical_id[2], self.physical_id[3]))
 477
 478       val += ("hosts=%s-%s, port=%s, %s, " %
 479               (self.logical_id[0], self.logical_id[1], self.logical_id[2],
 480                phy))
 481       if self.children and self.children.count(None) == 0:
 482         val += "backend=%s, metadev=%s" % (self.children[0], self.children[1])
 483       else:
 484         val += "no local storage"
 485     else:
 486       val = ("<Disk(type=%s, logical_id=%s, physical_id=%s, children=%s" %
 487              (self.dev_type, self.logical_id, self.physical_id, self.children))
 488     if self.iv_name is None:
 489       val += ", not visible"
 490     else:
 491       val += ", visible as /dev/%s" % self.iv_name
 492     val += ", size=%dm)>" % self.size
 493     return val
 494
 495
 496 class Instance(TaggableObject):
 497   """Config object representing an instance."""
 498   __slots__ = TaggableObject.__slots__ + [
 499     "name",
 500     "primary_node",
 501     "os",
 502     "status",
 503     "memory",
 504     "vcpus",
 505     "nics",
 506     "disks",
 507     "disk_template",
 508     "network_port",
 509     "kernel_path",
 510     "initrd_path",
 511     "hvm_boot_order",
 512     "hvm_acpi",
 513     "hvm_pae",
 514     "hvm_cdrom_image_path",
 515     "vnc_bind_address",
 516     ]
 517
 518   def _ComputeSecondaryNodes(self):
 519     """Compute the list of secondary nodes.
 520
 521     Since the data is already there (in the drbd disks), keeping it as
 522     a separate normal attribute is redundant and if not properly
 523     synchronised can cause problems. Thus it's better to compute it
 524     dynamically.
 525
 526     """
 527     def _Helper(primary, sec_nodes, device):
 528       """Recursively computes secondary nodes given a top device."""
 529       if device.dev_type in constants.LDS_DRBD:
 530         nodea, nodeb, dummy = device.logical_id
 531         if nodea == primary:
 532           candidate = nodeb
 533         else:
 534           candidate = nodea
 535         if candidate not in sec_nodes:
 536           sec_nodes.append(candidate)
 537       if device.children:
 538         for child in device.children:
 539           _Helper(primary, sec_nodes, child)
 540
 541     secondary_nodes = []
 542     for device in self.disks:
 543       _Helper(self.primary_node, secondary_nodes, device)
 544     return tuple(secondary_nodes)
 545
 546   secondary_nodes = property(_ComputeSecondaryNodes, None, None,
 547                              "List of secondary nodes")
 548
 549   def MapLVsByNode(self, lvmap=None, devs=None, node=None):
 550     """Provide a mapping of nodes to LVs this instance owns.
 551
 552     This function figures out what logical volumes should belong on which
 553     nodes, recursing through a device tree.
 554
 555     Args:
 556       lvmap: (optional) a dictionary to receive the 'node' : ['lv', ...] data.
 557
 558     Returns:
 559       None if lvmap arg is given.
 560       Otherwise, { 'nodename' : ['volume1', 'volume2', ...], ... }
 561
 562     """
 563     if node == None:
 564       node = self.primary_node
 565
 566     if lvmap is None:
 567       lvmap = { node : [] }
 568       ret = lvmap
 569     else:
 570       if not node in lvmap:
 571         lvmap[node] = []
 572       ret = None
 573
 574     if not devs:
 575       devs = self.disks
 576
 577     for dev in devs:
 578       if dev.dev_type == constants.LD_LV:
 579         lvmap[node].append(dev.logical_id[1])
 580
 581       elif dev.dev_type in constants.LDS_DRBD:
 582         if dev.logical_id[0] not in lvmap:
 583           lvmap[dev.logical_id[0]] = []
 584
 585         if dev.logical_id[1] not in lvmap:
 586           lvmap[dev.logical_id[1]] = []
 587
 588         if dev.children:
 589           self.MapLVsByNode(lvmap, dev.children, dev.logical_id[0])
 590           self.MapLVsByNode(lvmap, dev.children, dev.logical_id[1])
 591
 592       elif dev.children:
 593         self.MapLVsByNode(lvmap, dev.children, node)
 594
 595     return ret
 596
 597   def FindDisk(self, name):
 598     """Find a disk given having a specified name.
 599
 600     This will return the disk which has the given iv_name.
 601
 602     """
 603     for disk in self.disks:
 604       if disk.iv_name == name:
 605         return disk
 606
 607     return None
 608
 609   def ToDict(self):
 610     """Instance-specific conversion to standard python types.
 611
 612     This replaces the children lists of objects with lists of standard
 613     python types.
 614
 615     """
 616     bo = super(Instance, self).ToDict()
 617
 618     for attr in "nics", "disks":
 619       alist = bo.get(attr, None)
 620       if alist:
 621         nlist = self._ContainerToDicts(alist)
 622       else:
 623         nlist = []
 624       bo[attr] = nlist
 625     return bo
 626
 627   @classmethod
 628   def FromDict(cls, val):
 629     """Custom function for instances.
 630
 631     """
 632     obj = super(Instance, cls).FromDict(val)
 633     obj.nics = cls._ContainerFromDicts(obj.nics, list, NIC)
 634     obj.disks = cls._ContainerFromDicts(obj.disks, list, Disk)
 635     return obj
 636
 637
 638 class OS(ConfigObject):
 639   """Config object representing an operating system."""
 640   __slots__ = [
 641     "name",
 642     "path",
 643     "status",
 644     "api_version",
 645     "create_script",
 646     "export_script",
 647     "import_script",
 648     "rename_script",
 649     ]
 650
 651   @classmethod
 652   def FromInvalidOS(cls, err):
 653     """Create an OS from an InvalidOS error.
 654
 655     This routine knows how to convert an InvalidOS error to an OS
 656     object representing the broken OS with a meaningful error message.
 657
 658     """
 659     if not isinstance(err, errors.InvalidOS):
 660       raise errors.ProgrammerError("Trying to initialize an OS from an"
 661                                    " invalid object of type %s" % type(err))
 662
 663     return cls(name=err.args[0], path=err.args[1], status=err.args[2])
 664
 665   def __nonzero__(self):
 666     return self.status == constants.OS_VALID_STATUS
 667
 668   __bool__ = __nonzero__
 669
 670
 671 class Node(TaggableObject):
 672   """Config object representing a node."""
 673   __slots__ = TaggableObject.__slots__ + [
 674     "name",
 675     "primary_ip",
 676     "secondary_ip",
 677     ]
 678
 679
 680 class Cluster(TaggableObject):
 681   """Config object representing the cluster."""
 682   __slots__ = TaggableObject.__slots__ + [
 683     "serial_no",
 684     "rsahostkeypub",
 685     "highest_used_port",
 686     "tcpudp_port_pool",
 687     "mac_prefix",
 688     "volume_group_name",
 689     "default_bridge",
 690     ]
 691
 692   def ToDict(self):
 693     """Custom function for cluster.
 694
 695     """
 696     mydict = super(Cluster, self).ToDict()
 697     mydict["tcpudp_port_pool"] = list(self.tcpudp_port_pool)
 698     return mydict
 699
 700   @classmethod
 701   def FromDict(cls, val):
 702     """Custom function for cluster.
 703
 704     """
 705     obj = super(Cluster, cls).FromDict(val)
 706     if not isinstance(obj.tcpudp_port_pool, set):
 707       obj.tcpudp_port_pool = set(obj.tcpudp_port_pool)
 708     return obj
 709
 710
 711 class SerializableConfigParser(ConfigParser.SafeConfigParser):
 712   """Simple wrapper over ConfigParse that allows serialization.
 713
 714   This class is basically ConfigParser.SafeConfigParser with two
 715   additional methods that allow it to serialize/unserialize to/from a
 716   buffer.
 717
 718   """
 719   def Dumps(self):
 720     """Dump this instance and return the string representation."""
 721     buf = StringIO()
 722     self.write(buf)
 723     return buf.getvalue()
 724
 725   @staticmethod
 726   def Loads(data):
 727     """Load data from a string."""
 728     buf = StringIO(data)
 729     cfp = SerializableConfigParser()
 730     cfp.readfp(buf)
 731     return cfp