Statistics
| Branch: | Tag: | Revision:

root / lib / objects.py @ 162c1c1f

History | View | Annotate | Download (20.6 kB)

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 simplejson
31
import ConfigParser
32
import re
33
from cStringIO import StringIO
34

    
35
from ganeti import errors
36
from ganeti import constants
37

    
38

    
39
__all__ = ["ConfigObject", "ConfigData", "NIC", "Disk", "Instance",
40
           "OS", "Node", "Cluster"]
41

    
42

    
43
# Check whether the simplejson module supports indentation
44
_JSON_INDENT = 2
45
try:
46
  simplejson.dumps(1, indent=_JSON_INDENT)
47
except TypeError:
48
  _JSON_INDENT = None
49

    
50

    
51
class ConfigObject(object):
52
  """A generic config object.
53

54
  It has the following properties:
55

56
    - provides somewhat safe recursive unpickling and pickling for its classes
57
    - unset attributes which are defined in slots are always returned
58
      as None instead of raising an error
59

60
  Classes derived from this must always declare __slots__ (we use many
61
  config objects and the memory reduction is useful.
62

63
  """
64
  __slots__ = []
65

    
66
  def __init__(self, **kwargs):
67
    for k, v in kwargs.iteritems():
68
      setattr(self, k, v)
69

    
70
  def __getattr__(self, name):
71
    if name not in self.__slots__:
72
      raise AttributeError("Invalid object attribute %s.%s" %
73
                           (type(self).__name__, name))
74
    return None
75

    
76
  def __setitem__(self, key, value):
77
    if key not in self.__slots__:
78
      raise KeyError(key)
79
    setattr(self, key, value)
80

    
81
  def __getstate__(self):
82
    state = {}
83
    for name in self.__slots__:
84
      if hasattr(self, name):
85
        state[name] = getattr(self, name)
86
    return state
87

    
88
  def __setstate__(self, state):
89
    for name in state:
90
      if name in self.__slots__:
91
        setattr(self, name, state[name])
92

    
93
  def Dump(self, fobj):
94
    """Dump to a file object.
95

96
    """
97
    data = self.ToDict()
98
    if _JSON_INDENT is None:
99
      simplejson.dump(data, fobj)
100
    else:
101
      simplejson.dump(data, fobj, indent=_JSON_INDENT)
102

    
103
  @classmethod
104
  def Load(cls, fobj):
105
    """Load data from the given stream.
106

107
    """
108
    return cls.FromDict(simplejson.load(fobj))
109

    
110
  def Dumps(self):
111
    """Dump and return the string representation."""
112
    buf = StringIO()
113
    self.Dump(buf)
114
    return buf.getvalue()
115

    
116
  @classmethod
117
  def Loads(cls, data):
118
    """Load data from a string."""
119
    return cls.Load(StringIO(data))
120

    
121
  def ToDict(self):
122
    """Convert to a dict holding only standard python types.
123

124
    The generic routine just dumps all of this object's attributes in
125
    a dict. It does not work if the class has children who are
126
    ConfigObjects themselves (e.g. the nics list in an Instance), in
127
    which case the object should subclass the function in order to
128
    make sure all objects returned are only standard python types.
129

130
    """
131
    return dict([(k, getattr(self, k, None)) for k in self.__slots__])
132

    
133
  @classmethod
134
  def FromDict(cls, val):
135
    """Create an object from a dictionary.
136

137
    This generic routine takes a dict, instantiates a new instance of
138
    the given class, and sets attributes based on the dict content.
139

140
    As for `ToDict`, this does not work if the class has children
141
    who are ConfigObjects themselves (e.g. the nics list in an
142
    Instance), in which case the object should subclass the function
143
    and alter the objects.
144

145
    """
146
    if not isinstance(val, dict):
147
      raise errors.ConfigurationError("Invalid object passed to FromDict:"
148
                                      " expected dict, got %s" % type(val))
149
    val_str = dict([(str(k), v) for k, v in val.iteritems()])
150
    obj = cls(**val_str)
151
    return obj
152

    
153
  @staticmethod
154
  def _ContainerToDicts(container):
155
    """Convert the elements of a container to standard python types.
156

157
    This method converts a container with elements derived from
158
    ConfigData to standard python types. If the container is a dict,
159
    we don't touch the keys, only the values.
160

161
    """
162
    if isinstance(container, dict):
163
      ret = dict([(k, v.ToDict()) for k, v in container.iteritems()])
164
    elif isinstance(container, (list, tuple, set, frozenset)):
165
      ret = [elem.ToDict() for elem in container]
166
    else:
167
      raise TypeError("Invalid type %s passed to _ContainerToDicts" %
168
                      type(container))
169
    return ret
170

    
171
  @staticmethod
172
  def _ContainerFromDicts(source, c_type, e_type):
173
    """Convert a container from standard python types.
174

175
    This method converts a container with standard python types to
176
    ConfigData objects. If the container is a dict, we don't touch the
177
    keys, only the values.
178

179
    """
180
    if not isinstance(c_type, type):
181
      raise TypeError("Container type %s passed to _ContainerFromDicts is"
182
                      " not a type" % type(c_type))
183
    if c_type is dict:
184
      ret = dict([(k, e_type.FromDict(v)) for k, v in source.iteritems()])
185
    elif c_type in (list, tuple, set, frozenset):
186
      ret = c_type([e_type.FromDict(elem) for elem in source])
187
    else:
188
      raise TypeError("Invalid container type %s passed to"
189
                      " _ContainerFromDicts" % c_type)
190
    return ret
191

    
192
  def __repr__(self):
193
    """Implement __repr__ for ConfigObjects."""
194
    return repr(self.ToDict())
195

    
196

    
197
class TaggableObject(ConfigObject):
198
  """An generic class supporting tags.
199

200
  """
201
  __slots__ = ConfigObject.__slots__ + ["tags"]
202

    
203
  @staticmethod
204
  def ValidateTag(tag):
205
    """Check if a tag is valid.
206

207
    If the tag is invalid, an errors.TagError will be raised. The
208
    function has no return value.
209

210
    """
211
    if not isinstance(tag, basestring):
212
      raise errors.TagError("Invalid tag type (not a string)")
213
    if len(tag) > constants.MAX_TAG_LEN:
214
      raise errors.TagError("Tag too long (>%d characters)" %
215
                            constants.MAX_TAG_LEN)
216
    if not tag:
217
      raise errors.TagError("Tags cannot be empty")
218
    if not re.match("^[ \w.+*/:-]+$", tag):
219
      raise errors.TagError("Tag contains invalid characters")
220

    
221
  def GetTags(self):
222
    """Return the tags list.
223

224
    """
225
    tags = getattr(self, "tags", None)
226
    if tags is None:
227
      tags = self.tags = set()
228
    return tags
229

    
230
  def AddTag(self, tag):
231
    """Add a new tag.
232

233
    """
234
    self.ValidateTag(tag)
235
    tags = self.GetTags()
236
    if len(tags) >= constants.MAX_TAGS_PER_OBJ:
237
      raise errors.TagError("Too many tags")
238
    self.GetTags().add(tag)
239

    
240
  def RemoveTag(self, tag):
241
    """Remove a tag.
242

243
    """
244
    self.ValidateTag(tag)
245
    tags = self.GetTags()
246
    try:
247
      tags.remove(tag)
248
    except KeyError:
249
      raise errors.TagError("Tag not found")
250

    
251
  def ToDict(self):
252
    """Taggable-object-specific conversion to standard python types.
253

254
    This replaces the tags set with a list.
255

256
    """
257
    bo = super(TaggableObject, self).ToDict()
258

    
259
    tags = bo.get("tags", None)
260
    if isinstance(tags, set):
261
      bo["tags"] = list(tags)
262
    return bo
263

    
264
  @classmethod
265
  def FromDict(cls, val):
266
    """Custom function for instances.
267

268
    """
269
    obj = super(TaggableObject, cls).FromDict(val)
270
    if hasattr(obj, "tags") and isinstance(obj.tags, list):
271
      obj.tags = set(obj.tags)
272
    return obj
273

    
274

    
275
class ConfigData(ConfigObject):
276
  """Top-level config object."""
277
  __slots__ = ["cluster", "nodes", "instances"]
278

    
279
  def ToDict(self):
280
    """Custom function for top-level config data.
281

282
    This just replaces the list of instances, nodes and the cluster
283
    with standard python types.
284

285
    """
286
    mydict = super(ConfigData, self).ToDict()
287
    mydict["cluster"] = mydict["cluster"].ToDict()
288
    for key in "nodes", "instances":
289
      mydict[key] = self._ContainerToDicts(mydict[key])
290

    
291
    return mydict
292

    
293
  @classmethod
294
  def FromDict(cls, val):
295
    """Custom function for top-level config data
296

297
    """
298
    obj = super(ConfigData, cls).FromDict(val)
299
    obj.cluster = Cluster.FromDict(obj.cluster)
300
    obj.nodes = cls._ContainerFromDicts(obj.nodes, dict, Node)
301
    obj.instances = cls._ContainerFromDicts(obj.instances, dict, Instance)
302
    return obj
303

    
304

    
305
class NIC(ConfigObject):
306
  """Config object representing a network card."""
307
  __slots__ = ["mac", "ip", "bridge"]
308

    
309

    
310
class Disk(ConfigObject):
311
  """Config object representing a block device."""
312
  __slots__ = ["dev_type", "logical_id", "physical_id",
313
               "children", "iv_name", "size"]
314

    
315
  def CreateOnSecondary(self):
316
    """Test if this device needs to be created on a secondary node."""
317
    return self.dev_type in (constants.LD_DRBD7, constants.LD_DRBD8,
318
                             constants.LD_LV)
319

    
320
  def AssembleOnSecondary(self):
321
    """Test if this device needs to be assembled on a secondary node."""
322
    return self.dev_type in (constants.LD_DRBD7, constants.LD_DRBD8,
323
                             constants.LD_LV)
324

    
325
  def OpenOnSecondary(self):
326
    """Test if this device needs to be opened on a secondary node."""
327
    return self.dev_type in (constants.LD_LV,)
328

    
329
  def StaticDevPath(self):
330
    """Return the device path if this device type has a static one.
331

332
    Some devices (LVM for example) live always at the same /dev/ path,
333
    irrespective of their status. For such devices, we return this
334
    path, for others we return None.
335

336
    """
337
    if self.dev_type == constants.LD_LV:
338
      return "/dev/%s/%s" % (self.logical_id[0], self.logical_id[1])
339
    return None
340

    
341
  def ChildrenNeeded(self):
342
    """Compute the needed number of children for activation.
343

344
    This method will return either -1 (all children) or a positive
345
    number denoting the minimum number of children needed for
346
    activation (only mirrored devices will usually return >=0).
347

348
    Currently, only DRBD8 supports diskless activation (therefore we
349
    return 0), for all other we keep the previous semantics and return
350
    -1.
351

352
    """
353
    if self.dev_type == constants.LD_DRBD8:
354
      return 0
355
    return -1
356

    
357
  def GetNodes(self, node):
358
    """This function returns the nodes this device lives on.
359

360
    Given the node on which the parent of the device lives on (or, in
361
    case of a top-level device, the primary node of the devices'
362
    instance), this function will return a list of nodes on which this
363
    devices needs to (or can) be assembled.
364

365
    """
366
    if self.dev_type == constants.LD_LV or self.dev_type == constants.LD_MD_R1:
367
      result = [node]
368
    elif self.dev_type in constants.LDS_DRBD:
369
      result = [self.logical_id[0], self.logical_id[1]]
370
      if node not in result:
371
        raise errors.ConfigurationError("DRBD device passed unknown node")
372
    else:
373
      raise errors.ProgrammerError("Unhandled device type %s" % self.dev_type)
374
    return result
375

    
376
  def ComputeNodeTree(self, parent_node):
377
    """Compute the node/disk tree for this disk and its children.
378

379
    This method, given the node on which the parent disk lives, will
380
    return the list of all (node, disk) pairs which describe the disk
381
    tree in the most compact way. For example, a md/drbd/lvm stack
382
    will be returned as (primary_node, md) and (secondary_node, drbd)
383
    which represents all the top-level devices on the nodes. This
384
    means that on the primary node we need to activate the the md (and
385
    recursively all its children) and on the secondary node we need to
386
    activate the drbd device (and its children, the two lvm volumes).
387

388
    """
389
    my_nodes = self.GetNodes(parent_node)
390
    result = [(node, self) for node in my_nodes]
391
    if not self.children:
392
      # leaf device
393
      return result
394
    for node in my_nodes:
395
      for child in self.children:
396
        child_result = child.ComputeNodeTree(node)
397
        if len(child_result) == 1:
398
          # child (and all its descendants) is simple, doesn't split
399
          # over multiple hosts, so we don't need to describe it, our
400
          # own entry for this node describes it completely
401
          continue
402
        else:
403
          # check if child nodes differ from my nodes; note that
404
          # subdisk can differ from the child itself, and be instead
405
          # one of its descendants
406
          for subnode, subdisk in child_result:
407
            if subnode not in my_nodes:
408
              result.append((subnode, subdisk))
409
            # otherwise child is under our own node, so we ignore this
410
            # entry (but probably the other results in the list will
411
            # be different)
412
    return result
413

    
414
  def ToDict(self):
415
    """Disk-specific conversion to standard python types.
416

417
    This replaces the children lists of objects with lists of
418
    standard python types.
419

420
    """
421
    bo = super(Disk, self).ToDict()
422

    
423
    for attr in ("children",):
424
      alist = bo.get(attr, None)
425
      if alist:
426
        bo[attr] = self._ContainerToDicts(alist)
427
    return bo
428

    
429
  @classmethod
430
  def FromDict(cls, val):
431
    """Custom function for Disks
432

433
    """
434
    obj = super(Disk, cls).FromDict(val)
435
    if obj.children:
436
      obj.children = cls._ContainerFromDicts(obj.children, list, Disk)
437
    if obj.logical_id and isinstance(obj.logical_id, list):
438
      obj.logical_id = tuple(obj.logical_id)
439
    if obj.physical_id and isinstance(obj.physical_id, list):
440
      obj.physical_id = tuple(obj.physical_id)
441
    return obj
442

    
443
  def __str__(self):
444
    """Custom str() formatter for disks.
445

446
    """
447
    if self.dev_type == constants.LD_LV:
448
      val =  "<LogicalVolume(/dev/%s/%s" % self.logical_id
449
    elif self.dev_type in constants.LDS_DRBD:
450
      if self.dev_type == constants.LD_DRBD7:
451
        val = "<DRBD7("
452
      else:
453
        val = "<DRBD8("
454
      if self.physical_id is None:
455
        phy = "unconfigured"
456
      else:
457
        phy = ("configured as %s:%s %s:%s" %
458
               (self.physical_id[0], self.physical_id[1],
459
                self.physical_id[2], self.physical_id[3]))
460

    
461
      val += ("hosts=%s-%s, port=%s, %s, " %
462
              (self.logical_id[0], self.logical_id[1], self.logical_id[2],
463
               phy))
464
      if self.children and self.children.count(None) == 0:
465
        val += "backend=%s, metadev=%s" % (self.children[0], self.children[1])
466
      else:
467
        val += "no local storage"
468
    elif self.dev_type == constants.LD_MD_R1:
469
      val = "<MD_R1(uuid=%s, children=%s" % (self.physical_id, self.children)
470
    else:
471
      val = ("<Disk(type=%s, logical_id=%s, physical_id=%s, children=%s" %
472
             (self.dev_type, self.logical_id, self.physical_id, self.children))
473
    if self.iv_name is None:
474
      val += ", not visible"
475
    else:
476
      val += ", visible as /dev/%s" % self.iv_name
477
    val += ", size=%dm)>" % self.size
478
    return val
479

    
480

    
481
class Instance(TaggableObject):
482
  """Config object representing an instance."""
483
  __slots__ = TaggableObject.__slots__ + [
484
    "name",
485
    "primary_node",
486
    "os",
487
    "status",
488
    "memory",
489
    "vcpus",
490
    "nics",
491
    "disks",
492
    "disk_template",
493
    "network_port",
494
    "kernel_path",
495
    "initrd_path",
496
    "hvm_boot_order",
497
    ]
498

    
499
  def _ComputeSecondaryNodes(self):
500
    """Compute the list of secondary nodes.
501

502
    Since the data is already there (in the drbd disks), keeping it as
503
    a separate normal attribute is redundant and if not properly
504
    synchronised can cause problems. Thus it's better to compute it
505
    dynamically.
506

507
    """
508
    def _Helper(primary, sec_nodes, device):
509
      """Recursively computes secondary nodes given a top device."""
510
      if device.dev_type in constants.LDS_DRBD:
511
        nodea, nodeb, dummy = device.logical_id
512
        if nodea == primary:
513
          candidate = nodeb
514
        else:
515
          candidate = nodea
516
        if candidate not in sec_nodes:
517
          sec_nodes.append(candidate)
518
      if device.children:
519
        for child in device.children:
520
          _Helper(primary, sec_nodes, child)
521

    
522
    secondary_nodes = []
523
    for device in self.disks:
524
      _Helper(self.primary_node, secondary_nodes, device)
525
    return tuple(secondary_nodes)
526

    
527
  secondary_nodes = property(_ComputeSecondaryNodes, None, None,
528
                             "List of secondary nodes")
529

    
530
  def MapLVsByNode(self, lvmap=None, devs=None, node=None):
531
    """Provide a mapping of nodes to LVs this instance owns.
532

533
    This function figures out what logical volumes should belong on which
534
    nodes, recursing through a device tree.
535

536
    Args:
537
      lvmap: (optional) a dictionary to receive the 'node' : ['lv', ...] data.
538

539
    Returns:
540
      None if lvmap arg is given.
541
      Otherwise, { 'nodename' : ['volume1', 'volume2', ...], ... }
542

543
    """
544
    if node == None:
545
      node = self.primary_node
546

    
547
    if lvmap is None:
548
      lvmap = { node : [] }
549
      ret = lvmap
550
    else:
551
      if not node in lvmap:
552
        lvmap[node] = []
553
      ret = None
554

    
555
    if not devs:
556
      devs = self.disks
557

    
558
    for dev in devs:
559
      if dev.dev_type == constants.LD_LV:
560
        lvmap[node].append(dev.logical_id[1])
561

    
562
      elif dev.dev_type in constants.LDS_DRBD:
563
        if dev.logical_id[0] not in lvmap:
564
          lvmap[dev.logical_id[0]] = []
565

    
566
        if dev.logical_id[1] not in lvmap:
567
          lvmap[dev.logical_id[1]] = []
568

    
569
        if dev.children:
570
          self.MapLVsByNode(lvmap, dev.children, dev.logical_id[0])
571
          self.MapLVsByNode(lvmap, dev.children, dev.logical_id[1])
572

    
573
      elif dev.children:
574
        self.MapLVsByNode(lvmap, dev.children, node)
575

    
576
    return ret
577

    
578
  def FindDisk(self, name):
579
    """Find a disk given having a specified name.
580

581
    This will return the disk which has the given iv_name.
582

583
    """
584
    for disk in self.disks:
585
      if disk.iv_name == name:
586
        return disk
587

    
588
    return None
589

    
590
  def ToDict(self):
591
    """Instance-specific conversion to standard python types.
592

593
    This replaces the children lists of objects with lists of standard
594
    python types.
595

596
    """
597
    bo = super(Instance, self).ToDict()
598

    
599
    for attr in "nics", "disks":
600
      alist = bo.get(attr, None)
601
      if alist:
602
        nlist = self._ContainerToDicts(alist)
603
      else:
604
        nlist = []
605
      bo[attr] = nlist
606
    return bo
607

    
608
  @classmethod
609
  def FromDict(cls, val):
610
    """Custom function for instances.
611

612
    """
613
    obj = super(Instance, cls).FromDict(val)
614
    obj.nics = cls._ContainerFromDicts(obj.nics, list, NIC)
615
    obj.disks = cls._ContainerFromDicts(obj.disks, list, Disk)
616
    return obj
617

    
618

    
619
class OS(ConfigObject):
620
  """Config object representing an operating system."""
621
  __slots__ = [
622
    "name",
623
    "path",
624
    "status",
625
    "api_version",
626
    "create_script",
627
    "export_script",
628
    "import_script",
629
    "rename_script",
630
    ]
631

    
632
  @classmethod
633
  def FromInvalidOS(cls, err):
634
    """Create an OS from an InvalidOS error.
635

636
    This routine knows how to convert an InvalidOS error to an OS
637
    object representing the broken OS with a meaningful error message.
638

639
    """
640
    if not isinstance(err, errors.InvalidOS):
641
      raise errors.ProgrammerError("Trying to initialize an OS from an"
642
                                   " invalid object of type %s" % type(err))
643

    
644
    return cls(name=err.args[0], path=err.args[1], status=err.args[2])
645

    
646
  def __nonzero__(self):
647
    return self.status == constants.OS_VALID_STATUS
648

    
649
  __bool__ = __nonzero__
650

    
651
class Node(TaggableObject):
652
  """Config object representing a node."""
653
  __slots__ = TaggableObject.__slots__ + [
654
    "name",
655
    "primary_ip",
656
    "secondary_ip",
657
    ]
658

    
659

    
660
class Cluster(TaggableObject):
661
  """Config object representing the cluster."""
662
  __slots__ = TaggableObject.__slots__ + [
663
    "config_version",
664
    "serial_no",
665
    "rsahostkeypub",
666
    "highest_used_port",
667
    "tcpudp_port_pool",
668
    "mac_prefix",
669
    "volume_group_name",
670
    "default_bridge",
671
    ]
672

    
673
  def ToDict(self):
674
    """Custom function for cluster.
675

676
    """
677
    mydict = super(Cluster, self).ToDict()
678
    mydict["tcpudp_port_pool"] = list(self.tcpudp_port_pool)
679
    return mydict
680

    
681
  @classmethod
682
  def FromDict(cls, val):
683
    """Custom function for cluster.
684

685
    """
686
    obj = super(Cluster, cls).FromDict(val)
687
    if not isinstance(obj.tcpudp_port_pool, set):
688
      obj.tcpudp_port_pool = set(obj.tcpudp_port_pool)
689
    return obj
690

    
691

    
692
class SerializableConfigParser(ConfigParser.SafeConfigParser):
693
  """Simple wrapper over ConfigParse that allows serialization.
694

695
  This class is basically ConfigParser.SafeConfigParser with two
696
  additional methods that allow it to serialize/unserialize to/from a
697
  buffer.
698

699
  """
700
  def Dumps(self):
701
    """Dump this instance and return the string representation."""
702
    buf = StringIO()
703
    self.write(buf)
704
    return buf.getvalue()
705

    
706
  @staticmethod
707
  def Loads(data):
708
    """Load data from a string."""
709
    buf = StringIO(data)
710
    cfp = SerializableConfigParser()
711
    cfp.readfp(buf)
712
    return cfp