Statistics
| Branch: | Tag: | Revision:

root / lib / objects.py @ d2c807e4

History | View | Annotate | Download (19.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 GetNodes(self, node):
330
    """This function returns the nodes this device lives on.
331

332
    Given the node on which the parent of the device lives on (or, in
333
    case of a top-level device, the primary node of the devices'
334
    instance), this function will return a list of nodes on which this
335
    devices needs to (or can) be assembled.
336

337
    """
338
    if self.dev_type == constants.LD_LV or self.dev_type == constants.LD_MD_R1:
339
      result = [node]
340
    elif self.dev_type in constants.LDS_DRBD:
341
      result = [self.logical_id[0], self.logical_id[1]]
342
      if node not in result:
343
        raise errors.ConfigurationError("DRBD device passed unknown node")
344
    else:
345
      raise errors.ProgrammerError("Unhandled device type %s" % self.dev_type)
346
    return result
347

    
348
  def ComputeNodeTree(self, parent_node):
349
    """Compute the node/disk tree for this disk and its children.
350

351
    This method, given the node on which the parent disk lives, will
352
    return the list of all (node, disk) pairs which describe the disk
353
    tree in the most compact way. For example, a md/drbd/lvm stack
354
    will be returned as (primary_node, md) and (secondary_node, drbd)
355
    which represents all the top-level devices on the nodes. This
356
    means that on the primary node we need to activate the the md (and
357
    recursively all its children) and on the secondary node we need to
358
    activate the drbd device (and its children, the two lvm volumes).
359

360
    """
361
    my_nodes = self.GetNodes(parent_node)
362
    result = [(node, self) for node in my_nodes]
363
    if not self.children:
364
      # leaf device
365
      return result
366
    for node in my_nodes:
367
      for child in self.children:
368
        child_result = child.ComputeNodeTree(node)
369
        if len(child_result) == 1:
370
          # child (and all its descendants) is simple, doesn't split
371
          # over multiple hosts, so we don't need to describe it, our
372
          # own entry for this node describes it completely
373
          continue
374
        else:
375
          # check if child nodes differ from my nodes; note that
376
          # subdisk can differ from the child itself, and be instead
377
          # one of its descendants
378
          for subnode, subdisk in child_result:
379
            if subnode not in my_nodes:
380
              result.append((subnode, subdisk))
381
            # otherwise child is under our own node, so we ignore this
382
            # entry (but probably the other results in the list will
383
            # be different)
384
    return result
385

    
386
  def ToDict(self):
387
    """Disk-specific conversion to standard python types.
388

389
    This replaces the children lists of objects with lists of
390
    standard python types.
391

392
    """
393
    bo = super(Disk, self).ToDict()
394

    
395
    for attr in ("children",):
396
      alist = bo.get(attr, None)
397
      if alist:
398
        bo[attr] = self._ContainerToDicts(alist)
399
    return bo
400

    
401
  @classmethod
402
  def FromDict(cls, val):
403
    """Custom function for Disks
404

405
    """
406
    obj = super(Disk, cls).FromDict(val)
407
    if obj.children:
408
      obj.children = cls._ContainerFromDicts(obj.children, list, Disk)
409
    if obj.logical_id and isinstance(obj.logical_id, list):
410
      obj.logical_id = tuple(obj.logical_id)
411
    if obj.physical_id and isinstance(obj.physical_id, list):
412
      obj.physical_id = tuple(obj.physical_id)
413
    return obj
414

    
415
  def __str__(self):
416
    """Custom str() formatter for disks.
417

418
    """
419
    if self.dev_type == constants.LD_LV:
420
      val =  "<LogicalVolume(/dev/%s/%s" % self.logical_id
421
    elif self.dev_type in constants.LDS_DRBD:
422
      if self.dev_type == constants.LD_DRBD7:
423
        val = "<DRBD7("
424
      else:
425
        val = "<DRBD8("
426
      if self.physical_id is None:
427
        phy = "unconfigured"
428
      else:
429
        phy = ("configured as %s:%s %s:%s" %
430
               (self.physical_id[0], self.physical_id[1],
431
                self.physical_id[2], self.physical_id[3]))
432

    
433
      val += ("hosts=%s-%s, port=%s, %s, " %
434
              (self.logical_id[0], self.logical_id[1], self.logical_id[2],
435
               phy))
436
      if self.children and self.children.count(None) == 0:
437
        val += "backend=%s, metadev=%s" % (self.children[0], self.children[1])
438
      else:
439
        val += "no local storage"
440
    elif self.dev_type == constants.LD_MD_R1:
441
      val = "<MD_R1(uuid=%s, children=%s" % (self.physical_id, self.children)
442
    else:
443
      val = ("<Disk(type=%s, logical_id=%s, physical_id=%s, children=%s" %
444
             (self.dev_type, self.logical_id, self.physical_id, self.children))
445
    if self.iv_name is None:
446
      val += ", not visible"
447
    else:
448
      val += ", visible as /dev/%s" % self.iv_name
449
    val += ", size=%dm)>" % self.size
450
    return val
451

    
452

    
453
class Instance(TaggableObject):
454
  """Config object representing an instance."""
455
  __slots__ = TaggableObject.__slots__ + [
456
    "name",
457
    "primary_node",
458
    "os",
459
    "status",
460
    "memory",
461
    "vcpus",
462
    "nics",
463
    "disks",
464
    "disk_template",
465
    ]
466

    
467
  def _ComputeSecondaryNodes(self):
468
    """Compute the list of secondary nodes.
469

470
    Since the data is already there (in the drbd disks), keeping it as
471
    a separate normal attribute is redundant and if not properly
472
    synchronised can cause problems. Thus it's better to compute it
473
    dynamically.
474

475
    """
476
    def _Helper(primary, sec_nodes, device):
477
      """Recursively computes secondary nodes given a top device."""
478
      if device.dev_type in constants.LDS_DRBD:
479
        nodea, nodeb, dummy = device.logical_id
480
        if nodea == primary:
481
          candidate = nodeb
482
        else:
483
          candidate = nodea
484
        if candidate not in sec_nodes:
485
          sec_nodes.append(candidate)
486
      if device.children:
487
        for child in device.children:
488
          _Helper(primary, sec_nodes, child)
489

    
490
    secondary_nodes = []
491
    for device in self.disks:
492
      _Helper(self.primary_node, secondary_nodes, device)
493
    return tuple(secondary_nodes)
494

    
495
  secondary_nodes = property(_ComputeSecondaryNodes, None, None,
496
                             "List of secondary nodes")
497

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

501
    This function figures out what logical volumes should belong on which
502
    nodes, recursing through a device tree.
503

504
    Args:
505
      lvmap: (optional) a dictionary to receive the 'node' : ['lv', ...] data.
506

507
    Returns:
508
      None if lvmap arg is given.
509
      Otherwise, { 'nodename' : ['volume1', 'volume2', ...], ... }
510

511
    """
512
    if node == None:
513
      node = self.primary_node
514

    
515
    if lvmap is None:
516
      lvmap = { node : [] }
517
      ret = lvmap
518
    else:
519
      if not node in lvmap:
520
        lvmap[node] = []
521
      ret = None
522

    
523
    if not devs:
524
      devs = self.disks
525

    
526
    for dev in devs:
527
      if dev.dev_type == constants.LD_LV:
528
        lvmap[node].append(dev.logical_id[1])
529

    
530
      elif dev.dev_type in constants.LDS_DRBD:
531
        if dev.logical_id[0] not in lvmap:
532
          lvmap[dev.logical_id[0]] = []
533

    
534
        if dev.logical_id[1] not in lvmap:
535
          lvmap[dev.logical_id[1]] = []
536

    
537
        if dev.children:
538
          self.MapLVsByNode(lvmap, dev.children, dev.logical_id[0])
539
          self.MapLVsByNode(lvmap, dev.children, dev.logical_id[1])
540

    
541
      elif dev.children:
542
        self.MapLVsByNode(lvmap, dev.children, node)
543

    
544
    return ret
545

    
546
  def FindDisk(self, name):
547
    """Find a disk given having a specified name.
548

549
    This will return the disk which has the given iv_name.
550

551
    """
552
    for disk in self.disks:
553
      if disk.iv_name == name:
554
        return disk
555

    
556
    return None
557

    
558
  def ToDict(self):
559
    """Instance-specific conversion to standard python types.
560

561
    This replaces the children lists of objects with lists of standard
562
    python types.
563

564
    """
565
    bo = super(Instance, self).ToDict()
566

    
567
    for attr in "nics", "disks":
568
      alist = bo.get(attr, None)
569
      if alist:
570
        nlist = self._ContainerToDicts(alist)
571
      else:
572
        nlist = []
573
      bo[attr] = nlist
574
    return bo
575

    
576
  @classmethod
577
  def FromDict(cls, val):
578
    """Custom function for instances.
579

580
    """
581
    obj = super(Instance, cls).FromDict(val)
582
    obj.nics = cls._ContainerFromDicts(obj.nics, list, NIC)
583
    obj.disks = cls._ContainerFromDicts(obj.disks, list, Disk)
584
    return obj
585

    
586

    
587
class OS(ConfigObject):
588
  """Config object representing an operating system."""
589
  __slots__ = [
590
    "name",
591
    "path",
592
    "status",
593
    "api_version",
594
    "create_script",
595
    "export_script",
596
    "import_script",
597
    "rename_script",
598
    ]
599

    
600
  @classmethod
601
  def FromInvalidOS(cls, err):
602
    """Create an OS from an InvalidOS error.
603

604
    This routine knows how to convert an InvalidOS error to an OS
605
    object representing the broken OS with a meaningful error message.
606

607
    """
608
    if not isinstance(err, errors.InvalidOS):
609
      raise errors.ProgrammerError("Trying to initialize an OS from an"
610
                                   " invalid object of type %s" % type(err))
611

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

    
614
  def __nonzero__(self):
615
    return self.status == constants.OS_VALID_STATUS
616

    
617
  __bool__ = __nonzero__
618

    
619
class Node(TaggableObject):
620
  """Config object representing a node."""
621
  __slots__ = TaggableObject.__slots__ + [
622
    "name",
623
    "primary_ip",
624
    "secondary_ip",
625
    ]
626

    
627

    
628
class Cluster(TaggableObject):
629
  """Config object representing the cluster."""
630
  __slots__ = TaggableObject.__slots__ + [
631
    "config_version",
632
    "serial_no",
633
    "rsahostkeypub",
634
    "highest_used_port",
635
    "tcpudp_port_pool",
636
    "mac_prefix",
637
    "volume_group_name",
638
    "default_bridge",
639
    ]
640

    
641
  def ToDict(self):
642
    """Custom function for cluster.
643

644
    """
645
    mydict = super(Cluster, self).ToDict()
646
    mydict["tcpudp_port_pool"] = list(self.tcpudp_port_pool)
647
    return mydict
648

    
649
  @classmethod
650
  def FromDict(cls, val):
651
    """Custom function for cluster.
652

653
    """
654
    obj = super(Cluster, cls).FromDict(val)
655
    if not isinstance(obj.tcpudp_port_pool, set):
656
      obj.tcpudp_port_pool = set(obj.tcpudp_port_pool)
657
    return obj
658

    
659

    
660
class SerializableConfigParser(ConfigParser.SafeConfigParser):
661
  """Simple wrapper over ConfigParse that allows serialization.
662

663
  This class is basically ConfigParser.SafeConfigParser with two
664
  additional methods that allow it to serialize/unserialize to/from a
665
  buffer.
666

667
  """
668
  def Dumps(self):
669
    """Dump this instance and return the string representation."""
670
    buf = StringIO()
671
    self.write(buf)
672
    return buf.getvalue()
673

    
674
  @staticmethod
675
  def Loads(data):
676
    """Load data from a string."""
677
    buf = StringIO(data)
678
    cfp = SerializableConfigParser()
679
    cfp.readfp(buf)
680
    return cfp