Statistics
| Branch: | Tag: | Revision:

root / lib / objects.py @ 0402302c

History | View | Annotate | Download (21.9 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 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 in [constants.LD_LV, constants.LD_MD_R1,
330
                         constants.LD_FILE]:
331
      result = [node]
332
    elif self.dev_type in constants.LDS_DRBD:
333
      result = [self.logical_id[0], self.logical_id[1]]
334
      if node not in result:
335
        raise errors.ConfigurationError("DRBD device passed unknown node")
336
    else:
337
      raise errors.ProgrammerError("Unhandled device type %s" % self.dev_type)
338
    return result
339

    
340
  def ComputeNodeTree(self, parent_node):
341
    """Compute the node/disk tree for this disk and its children.
342

343
    This method, given the node on which the parent disk lives, will
344
    return the list of all (node, disk) pairs which describe the disk
345
    tree in the most compact way. For example, a drbd/lvm stack
346
    will be returned as (primary_node, drbd) and (secondary_node, drbd)
347
    which represents all the top-level devices on the nodes.
348

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

    
375
  def RecordGrow(self, amount):
376
    """Update the size of this disk after growth.
377

378
    This method recurses over the disks's children and updates their
379
    size correspondigly. The method needs to be kept in sync with the
380
    actual algorithms from bdev.
381

382
    """
383
    if self.dev_type == constants.LD_LV:
384
      self.size += amount
385
    elif self.dev_type == constants.LD_DRBD8:
386
      if self.children:
387
        self.children[0].RecordGrow(amount)
388
      self.size += amount
389
    else:
390
      raise errors.ProgrammerError("Disk.RecordGrow called for unsupported"
391
                                   " disk type %s" % self.dev_type)
392

    
393
  def SetPhysicalID(self, target_node, nodes_ip):
394
    """Convert the logical ID to the physical ID.
395

396
    This is used only for drbd, which needs ip/port configuration.
397

398
    The routine descends down and updates its children also, because
399
    this helps when the only the top device is passed to the remote
400
    node.
401

402
    Arguments:
403
      - target_node: the node we wish to configure for
404
      - nodes_ip: a mapping of node name to ip
405

406
    The target_node must exist in in nodes_ip, and must be one of the
407
    nodes in the logical ID for each of the DRBD devices encountered
408
    in the disk tree.
409

410
    """
411
    if self.children:
412
      for child in self.children:
413
        child.SetPhysicalID(target_node, nodes_ip)
414

    
415
    if self.logical_id is None and self.physical_id is not None:
416
      return
417
    if self.dev_type in constants.LDS_DRBD:
418
      pnode, snode, port = self.logical_id
419
      if target_node not in (pnode, snode):
420
        raise errors.ConfigurationError("DRBD device not knowing node %s" %
421
                                        target_node)
422
      pnode_ip = nodes_ip.get(pnode, None)
423
      snode_ip = nodes_ip.get(snode, None)
424
      if pnode_ip is None or snode_ip is None:
425
        raise errors.ConfigurationError("Can't find primary or secondary node"
426
                                        " for %s" % str(self))
427
      if pnode == target_node:
428
        self.physical_id = (pnode_ip, port,
429
                            snode_ip, port)
430
      else: # it must be secondary, we tested above
431
        self.physical_id = (snode_ip, port,
432
                            pnode_ip, port)
433
    else:
434
      self.physical_id = self.logical_id
435
    return
436

    
437
  def ToDict(self):
438
    """Disk-specific conversion to standard python types.
439

440
    This replaces the children lists of objects with lists of
441
    standard python types.
442

443
    """
444
    bo = super(Disk, self).ToDict()
445

    
446
    for attr in ("children",):
447
      alist = bo.get(attr, None)
448
      if alist:
449
        bo[attr] = self._ContainerToDicts(alist)
450
    return bo
451

    
452
  @classmethod
453
  def FromDict(cls, val):
454
    """Custom function for Disks
455

456
    """
457
    obj = super(Disk, cls).FromDict(val)
458
    if obj.children:
459
      obj.children = cls._ContainerFromDicts(obj.children, list, Disk)
460
    if obj.logical_id and isinstance(obj.logical_id, list):
461
      obj.logical_id = tuple(obj.logical_id)
462
    if obj.physical_id and isinstance(obj.physical_id, list):
463
      obj.physical_id = tuple(obj.physical_id)
464
    return obj
465

    
466
  def __str__(self):
467
    """Custom str() formatter for disks.
468

469
    """
470
    if self.dev_type == constants.LD_LV:
471
      val =  "<LogicalVolume(/dev/%s/%s" % self.logical_id
472
    elif self.dev_type in constants.LDS_DRBD:
473
      if self.dev_type == constants.LD_DRBD7:
474
        val = "<DRBD7("
475
      else:
476
        val = "<DRBD8("
477
      if self.physical_id is None:
478
        phy = "unconfigured"
479
      else:
480
        phy = ("configured as %s:%s %s:%s" %
481
               (self.physical_id[0], self.physical_id[1],
482
                self.physical_id[2], self.physical_id[3]))
483

    
484
      val += ("hosts=%s-%s, port=%s, %s, " %
485
              (self.logical_id[0], self.logical_id[1], self.logical_id[2],
486
               phy))
487
      if self.children and self.children.count(None) == 0:
488
        val += "backend=%s, metadev=%s" % (self.children[0], self.children[1])
489
      else:
490
        val += "no local storage"
491
    elif self.dev_type == constants.LD_MD_R1:
492
      val = "<MD_R1(uuid=%s, children=%s" % (self.physical_id, self.children)
493
    else:
494
      val = ("<Disk(type=%s, logical_id=%s, physical_id=%s, children=%s" %
495
             (self.dev_type, self.logical_id, self.physical_id, self.children))
496
    if self.iv_name is None:
497
      val += ", not visible"
498
    else:
499
      val += ", visible as /dev/%s" % self.iv_name
500
    val += ", size=%dm)>" % self.size
501
    return val
502

    
503

    
504
class Instance(TaggableObject):
505
  """Config object representing an instance."""
506
  __slots__ = TaggableObject.__slots__ + [
507
    "name",
508
    "primary_node",
509
    "os",
510
    "status",
511
    "memory",
512
    "vcpus",
513
    "nics",
514
    "disks",
515
    "disk_template",
516
    "network_port",
517
    "kernel_path",
518
    "initrd_path",
519
    "hvm_boot_order",
520
    "hvm_acpi",
521
    "hvm_pae",
522
    "hvm_cdrom_image_path",
523
    "vnc_bind_address",
524
    ]
525

    
526
  def _ComputeSecondaryNodes(self):
527
    """Compute the list of secondary nodes.
528

529
    Since the data is already there (in the drbd disks), keeping it as
530
    a separate normal attribute is redundant and if not properly
531
    synchronised can cause problems. Thus it's better to compute it
532
    dynamically.
533

534
    """
535
    def _Helper(primary, sec_nodes, device):
536
      """Recursively computes secondary nodes given a top device."""
537
      if device.dev_type in constants.LDS_DRBD:
538
        nodea, nodeb, dummy = device.logical_id
539
        if nodea == primary:
540
          candidate = nodeb
541
        else:
542
          candidate = nodea
543
        if candidate not in sec_nodes:
544
          sec_nodes.append(candidate)
545
      if device.children:
546
        for child in device.children:
547
          _Helper(primary, sec_nodes, child)
548

    
549
    secondary_nodes = []
550
    for device in self.disks:
551
      _Helper(self.primary_node, secondary_nodes, device)
552
    return tuple(secondary_nodes)
553

    
554
  secondary_nodes = property(_ComputeSecondaryNodes, None, None,
555
                             "List of secondary nodes")
556

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

560
    This function figures out what logical volumes should belong on which
561
    nodes, recursing through a device tree.
562

563
    Args:
564
      lvmap: (optional) a dictionary to receive the 'node' : ['lv', ...] data.
565

566
    Returns:
567
      None if lvmap arg is given.
568
      Otherwise, { 'nodename' : ['volume1', 'volume2', ...], ... }
569

570
    """
571
    if node == None:
572
      node = self.primary_node
573

    
574
    if lvmap is None:
575
      lvmap = { node : [] }
576
      ret = lvmap
577
    else:
578
      if not node in lvmap:
579
        lvmap[node] = []
580
      ret = None
581

    
582
    if not devs:
583
      devs = self.disks
584

    
585
    for dev in devs:
586
      if dev.dev_type == constants.LD_LV:
587
        lvmap[node].append(dev.logical_id[1])
588

    
589
      elif dev.dev_type in constants.LDS_DRBD:
590
        if dev.logical_id[0] not in lvmap:
591
          lvmap[dev.logical_id[0]] = []
592

    
593
        if dev.logical_id[1] not in lvmap:
594
          lvmap[dev.logical_id[1]] = []
595

    
596
        if dev.children:
597
          self.MapLVsByNode(lvmap, dev.children, dev.logical_id[0])
598
          self.MapLVsByNode(lvmap, dev.children, dev.logical_id[1])
599

    
600
      elif dev.children:
601
        self.MapLVsByNode(lvmap, dev.children, node)
602

    
603
    return ret
604

    
605
  def FindDisk(self, name):
606
    """Find a disk given having a specified name.
607

608
    This will return the disk which has the given iv_name.
609

610
    """
611
    for disk in self.disks:
612
      if disk.iv_name == name:
613
        return disk
614

    
615
    return None
616

    
617
  def ToDict(self):
618
    """Instance-specific conversion to standard python types.
619

620
    This replaces the children lists of objects with lists of standard
621
    python types.
622

623
    """
624
    bo = super(Instance, self).ToDict()
625

    
626
    for attr in "nics", "disks":
627
      alist = bo.get(attr, None)
628
      if alist:
629
        nlist = self._ContainerToDicts(alist)
630
      else:
631
        nlist = []
632
      bo[attr] = nlist
633
    return bo
634

    
635
  @classmethod
636
  def FromDict(cls, val):
637
    """Custom function for instances.
638

639
    """
640
    obj = super(Instance, cls).FromDict(val)
641
    obj.nics = cls._ContainerFromDicts(obj.nics, list, NIC)
642
    obj.disks = cls._ContainerFromDicts(obj.disks, list, Disk)
643
    return obj
644

    
645

    
646
class OS(ConfigObject):
647
  """Config object representing an operating system."""
648
  __slots__ = [
649
    "name",
650
    "path",
651
    "status",
652
    "api_version",
653
    "create_script",
654
    "export_script",
655
    "import_script",
656
    "rename_script",
657
    ]
658

    
659
  @classmethod
660
  def FromInvalidOS(cls, err):
661
    """Create an OS from an InvalidOS error.
662

663
    This routine knows how to convert an InvalidOS error to an OS
664
    object representing the broken OS with a meaningful error message.
665

666
    """
667
    if not isinstance(err, errors.InvalidOS):
668
      raise errors.ProgrammerError("Trying to initialize an OS from an"
669
                                   " invalid object of type %s" % type(err))
670

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

    
673
  def __nonzero__(self):
674
    return self.status == constants.OS_VALID_STATUS
675

    
676
  __bool__ = __nonzero__
677

    
678

    
679
class Node(TaggableObject):
680
  """Config object representing a node."""
681
  __slots__ = TaggableObject.__slots__ + [
682
    "name",
683
    "primary_ip",
684
    "secondary_ip",
685
    ]
686

    
687

    
688
class Cluster(TaggableObject):
689
  """Config object representing the cluster."""
690
  __slots__ = TaggableObject.__slots__ + [
691
    "config_version",
692
    "serial_no",
693
    "rsahostkeypub",
694
    "highest_used_port",
695
    "tcpudp_port_pool",
696
    "mac_prefix",
697
    "volume_group_name",
698
    "default_bridge",
699
    ]
700

    
701
  def ToDict(self):
702
    """Custom function for cluster.
703

704
    """
705
    mydict = super(Cluster, self).ToDict()
706
    mydict["tcpudp_port_pool"] = list(self.tcpudp_port_pool)
707
    return mydict
708

    
709
  @classmethod
710
  def FromDict(cls, val):
711
    """Custom function for cluster.
712

713
    """
714
    obj = super(Cluster, cls).FromDict(val)
715
    if not isinstance(obj.tcpudp_port_pool, set):
716
      obj.tcpudp_port_pool = set(obj.tcpudp_port_pool)
717
    return obj
718

    
719

    
720
class SerializableConfigParser(ConfigParser.SafeConfigParser):
721
  """Simple wrapper over ConfigParse that allows serialization.
722

723
  This class is basically ConfigParser.SafeConfigParser with two
724
  additional methods that allow it to serialize/unserialize to/from a
725
  buffer.
726

727
  """
728
  def Dumps(self):
729
    """Dump this instance and return the string representation."""
730
    buf = StringIO()
731
    self.write(buf)
732
    return buf.getvalue()
733

    
734
  @staticmethod
735
  def Loads(data):
736
    """Load data from a string."""
737
    buf = StringIO(data)
738
    cfp = SerializableConfigParser()
739
    cfp.readfp(buf)
740
    return cfp