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

   1 #
   2 #
   3
   4 # Copyright (C) 2006, 2007, 2010, 2011 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 """Block device abstraction"""
  23
  24 import re
  25 import time
  26 import errno
  27 import stat
  28 import pyparsing as pyp
  29 import os
  30 import logging
  31
  32 from ganeti import utils
  33 from ganeti import errors
  34 from ganeti import constants
  35 from ganeti import objects
  36 from ganeti import compat
  37 from ganeti import netutils
  38
  39
  40 # Size of reads in _CanReadDevice
  41 _DEVICE_READ_SIZE = 128 * 1024
  42
  43
  44 def _IgnoreError(fn, *args, **kwargs):
  45   """Executes the given function, ignoring BlockDeviceErrors.
  46
  47   This is used in order to simplify the execution of cleanup or
  48   rollback functions.
  49
  50   @rtype: boolean
  51   @return: True when fn didn't raise an exception, False otherwise
  52
  53   """
  54   try:
  55     fn(*args, **kwargs)
  56     return True
  57   except errors.BlockDeviceError, err:
  58     logging.warning("Caught BlockDeviceError but ignoring: %s", str(err))
  59     return False
  60
  61
  62 def _ThrowError(msg, *args):
  63   """Log an error to the node daemon and the raise an exception.
  64
  65   @type msg: string
  66   @param msg: the text of the exception
  67   @raise errors.BlockDeviceError
  68
  69   """
  70   if args:
  71     msg = msg % args
  72   logging.error(msg)
  73   raise errors.BlockDeviceError(msg)
  74
  75
  76 def _CanReadDevice(path):
  77   """Check if we can read from the given device.
  78
  79   This tries to read the first 128k of the device.
  80
  81   """
  82   try:
  83     utils.ReadFile(path, size=_DEVICE_READ_SIZE)
  84     return True
  85   except EnvironmentError:
  86     logging.warning("Can't read from device %s", path, exc_info=True)
  87     return False
  88
  89
  90 class BlockDev(object):
  91   """Block device abstract class.
  92
  93   A block device can be in the following states:
  94     - not existing on the system, and by `Create()` it goes into:
  95     - existing but not setup/not active, and by `Assemble()` goes into:
  96     - active read-write and by `Open()` it goes into
  97     - online (=used, or ready for use)
  98
  99   A device can also be online but read-only, however we are not using
 100   the readonly state (LV has it, if needed in the future) and we are
 101   usually looking at this like at a stack, so it's easier to
 102   conceptualise the transition from not-existing to online and back
 103   like a linear one.
 104
 105   The many different states of the device are due to the fact that we
 106   need to cover many device types:
 107     - logical volumes are created, lvchange -a y $lv, and used
 108     - drbd devices are attached to a local disk/remote peer and made primary
 109
 110   A block device is identified by three items:
 111     - the /dev path of the device (dynamic)
 112     - a unique ID of the device (static)
 113     - it's major/minor pair (dynamic)
 114
 115   Not all devices implement both the first two as distinct items. LVM
 116   logical volumes have their unique ID (the pair volume group, logical
 117   volume name) in a 1-to-1 relation to the dev path. For DRBD devices,
 118   the /dev path is again dynamic and the unique id is the pair (host1,
 119   dev1), (host2, dev2).
 120
 121   You can get to a device in two ways:
 122     - creating the (real) device, which returns you
 123       an attached instance (lvcreate)
 124     - attaching of a python instance to an existing (real) device
 125
 126   The second point, the attachement to a device, is different
 127   depending on whether the device is assembled or not. At init() time,
 128   we search for a device with the same unique_id as us. If found,
 129   good. It also means that the device is already assembled. If not,
 130   after assembly we'll have our correct major/minor.
 131
 132   """
 133   def __init__(self, unique_id, children, size):
 134     self._children = children
 135     self.dev_path = None
 136     self.unique_id = unique_id
 137     self.major = None
 138     self.minor = None
 139     self.attached = False
 140     self.size = size
 141
 142   def Assemble(self):
 143     """Assemble the device from its components.
 144
 145     Implementations of this method by child classes must ensure that:
 146       - after the device has been assembled, it knows its major/minor
 147         numbers; this allows other devices (usually parents) to probe
 148         correctly for their children
 149       - calling this method on an existing, in-use device is safe
 150       - if the device is already configured (and in an OK state),
 151         this method is idempotent
 152
 153     """
 154     pass
 155
 156   def Attach(self):
 157     """Find a device which matches our config and attach to it.
 158
 159     """
 160     raise NotImplementedError
 161
 162   def Close(self):
 163     """Notifies that the device will no longer be used for I/O.
 164
 165     """
 166     raise NotImplementedError
 167
 168   @classmethod
 169   def Create(cls, unique_id, children, size):
 170     """Create the device.
 171
 172     If the device cannot be created, it will return None
 173     instead. Error messages go to the logging system.
 174
 175     Note that for some devices, the unique_id is used, and for other,
 176     the children. The idea is that these two, taken together, are
 177     enough for both creation and assembly (later).
 178
 179     """
 180     raise NotImplementedError
 181
 182   def Remove(self):
 183     """Remove this device.
 184
 185     This makes sense only for some of the device types: LV and file
 186     storage. Also note that if the device can't attach, the removal
 187     can't be completed.
 188
 189     """
 190     raise NotImplementedError
 191
 192   def Rename(self, new_id):
 193     """Rename this device.
 194
 195     This may or may not make sense for a given device type.
 196
 197     """
 198     raise NotImplementedError
 199
 200   def Open(self, force=False):
 201     """Make the device ready for use.
 202
 203     This makes the device ready for I/O. For now, just the DRBD
 204     devices need this.
 205
 206     The force parameter signifies that if the device has any kind of
 207     --force thing, it should be used, we know what we are doing.
 208
 209     """
 210     raise NotImplementedError
 211
 212   def Shutdown(self):
 213     """Shut down the device, freeing its children.
 214
 215     This undoes the `Assemble()` work, except for the child
 216     assembling; as such, the children on the device are still
 217     assembled after this call.
 218
 219     """
 220     raise NotImplementedError
 221
 222   def SetSyncSpeed(self, speed):
 223     """Adjust the sync speed of the mirror.
 224
 225     In case this is not a mirroring device, this is no-op.
 226
 227     """
 228     result = True
 229     if self._children:
 230       for child in self._children:
 231         result = result and child.SetSyncSpeed(speed)
 232     return result
 233
 234   def PauseResumeSync(self, pause):
 235     """Pause/Resume the sync of the mirror.
 236
 237     In case this is not a mirroring device, this is no-op.
 238
 239     @param pause: Wheater to pause or resume
 240
 241     """
 242     result = True
 243     if self._children:
 244       for child in self._children:
 245         result = result and child.PauseResumeSync(pause)
 246     return result
 247
 248   def GetSyncStatus(self):
 249     """Returns the sync status of the device.
 250
 251     If this device is a mirroring device, this function returns the
 252     status of the mirror.
 253
 254     If sync_percent is None, it means the device is not syncing.
 255
 256     If estimated_time is None, it means we can't estimate
 257     the time needed, otherwise it's the time left in seconds.
 258
 259     If is_degraded is True, it means the device is missing
 260     redundancy. This is usually a sign that something went wrong in
 261     the device setup, if sync_percent is None.
 262
 263     The ldisk parameter represents the degradation of the local
 264     data. This is only valid for some devices, the rest will always
 265     return False (not degraded).
 266
 267     @rtype: objects.BlockDevStatus
 268
 269     """
 270     return objects.BlockDevStatus(dev_path=self.dev_path,
 271                                   major=self.major,
 272                                   minor=self.minor,
 273                                   sync_percent=None,
 274                                   estimated_time=None,
 275                                   is_degraded=False,
 276                                   ldisk_status=constants.LDS_OKAY)
 277
 278   def CombinedSyncStatus(self):
 279     """Calculate the mirror status recursively for our children.
 280
 281     The return value is the same as for `GetSyncStatus()` except the
 282     minimum percent and maximum time are calculated across our
 283     children.
 284
 285     @rtype: objects.BlockDevStatus
 286
 287     """
 288     status = self.GetSyncStatus()
 289
 290     min_percent = status.sync_percent
 291     max_time = status.estimated_time
 292     is_degraded = status.is_degraded
 293     ldisk_status = status.ldisk_status
 294
 295     if self._children:
 296       for child in self._children:
 297         child_status = child.GetSyncStatus()
 298
 299         if min_percent is None:
 300           min_percent = child_status.sync_percent
 301         elif child_status.sync_percent is not None:
 302           min_percent = min(min_percent, child_status.sync_percent)
 303
 304         if max_time is None:
 305           max_time = child_status.estimated_time
 306         elif child_status.estimated_time is not None:
 307           max_time = max(max_time, child_status.estimated_time)
 308
 309         is_degraded = is_degraded or child_status.is_degraded
 310
 311         if ldisk_status is None:
 312           ldisk_status = child_status.ldisk_status
 313         elif child_status.ldisk_status is not None:
 314           ldisk_status = max(ldisk_status, child_status.ldisk_status)
 315
 316     return objects.BlockDevStatus(dev_path=self.dev_path,
 317                                   major=self.major,
 318                                   minor=self.minor,
 319                                   sync_percent=min_percent,
 320                                   estimated_time=max_time,
 321                                   is_degraded=is_degraded,
 322                                   ldisk_status=ldisk_status)
 323
 324
 325   def SetInfo(self, text):
 326     """Update metadata with info text.
 327
 328     Only supported for some device types.
 329
 330     """
 331     for child in self._children:
 332       child.SetInfo(text)
 333
 334   def Grow(self, amount, dryrun):
 335     """Grow the block device.
 336
 337     @type amount: integer
 338     @param amount: the amount (in mebibytes) to grow with
 339     @type dryrun: boolean
 340     @param dryrun: whether to execute the operation in simulation mode
 341         only, without actually increasing the size
 342
 343     """
 344     raise NotImplementedError
 345
 346   def GetActualSize(self):
 347     """Return the actual disk size.
 348
 349     @note: the device needs to be active when this is called
 350
 351     """
 352     assert self.attached, "BlockDevice not attached in GetActualSize()"
 353     result = utils.RunCmd(["blockdev", "--getsize64", self.dev_path])
 354     if result.failed:
 355       _ThrowError("blockdev failed (%s): %s",
 356                   result.fail_reason, result.output)
 357     try:
 358       sz = int(result.output.strip())
 359     except (ValueError, TypeError), err:
 360       _ThrowError("Failed to parse blockdev output: %s", str(err))
 361     return sz
 362
 363   def __repr__(self):
 364     return ("<%s: unique_id: %s, children: %s, %s:%s, %s>" %
 365             (self.__class__, self.unique_id, self._children,
 366              self.major, self.minor, self.dev_path))
 367
 368
 369 class LogicalVolume(BlockDev):
 370   """Logical Volume block device.
 371
 372   """
 373   _VALID_NAME_RE = re.compile("^[a-zA-Z0-9+_.-]*$")
 374   _INVALID_NAMES = frozenset([".", "..", "snapshot", "pvmove"])
 375   _INVALID_SUBSTRINGS = frozenset(["_mlog", "_mimage"])
 376
 377   def __init__(self, unique_id, children, size):
 378     """Attaches to a LV device.
 379
 380     The unique_id is a tuple (vg_name, lv_name)
 381
 382     """
 383     super(LogicalVolume, self).__init__(unique_id, children, size)
 384     if not isinstance(unique_id, (tuple, list)) or len(unique_id) != 2:
 385       raise ValueError("Invalid configuration data %s" % str(unique_id))
 386     self._vg_name, self._lv_name = unique_id
 387     self._ValidateName(self._vg_name)
 388     self._ValidateName(self._lv_name)
 389     self.dev_path = utils.PathJoin("/dev", self._vg_name, self._lv_name)
 390     self._degraded = True
 391     self.major = self.minor = self.pe_size = self.stripe_count = None
 392     self.Attach()
 393
 394   @classmethod
 395   def Create(cls, unique_id, children, size):
 396     """Create a new logical volume.
 397
 398     """
 399     if not isinstance(unique_id, (tuple, list)) or len(unique_id) != 2:
 400       raise errors.ProgrammerError("Invalid configuration data %s" %
 401                                    str(unique_id))
 402     vg_name, lv_name = unique_id
 403     cls._ValidateName(vg_name)
 404     cls._ValidateName(lv_name)
 405     pvs_info = cls.GetPVInfo([vg_name])
 406     if not pvs_info:
 407       _ThrowError("Can't compute PV info for vg %s", vg_name)
 408     pvs_info.sort()
 409     pvs_info.reverse()
 410
 411     pvlist = [ pv[1] for pv in pvs_info ]
 412     if compat.any(":" in v for v in pvlist):
 413       _ThrowError("Some of your PVs have the invalid character ':' in their"
 414                   " name, this is not supported - please filter them out"
 415                   " in lvm.conf using either 'filter' or 'preferred_names'")
 416     free_size = sum([ pv[0] for pv in pvs_info ])
 417     current_pvs = len(pvlist)
 418     stripes = min(current_pvs, constants.LVM_STRIPECOUNT)
 419
 420     # The size constraint should have been checked from the master before
 421     # calling the create function.
 422     if free_size < size:
 423       _ThrowError("Not enough free space: required %s,"
 424                   " available %s", size, free_size)
 425     cmd = ["lvcreate", "-L%dm" % size, "-n%s" % lv_name]
 426     # If the free space is not well distributed, we won't be able to
 427     # create an optimally-striped volume; in that case, we want to try
 428     # with N, N-1, ..., 2, and finally 1 (non-stripped) number of
 429     # stripes
 430     for stripes_arg in range(stripes, 0, -1):
 431       result = utils.RunCmd(cmd + ["-i%d" % stripes_arg] + [vg_name] + pvlist)
 432       if not result.failed:
 433         break
 434     if result.failed:
 435       _ThrowError("LV create failed (%s): %s",
 436                   result.fail_reason, result.output)
 437     return LogicalVolume(unique_id, children, size)
 438
 439   @staticmethod
 440   def _GetVolumeInfo(lvm_cmd, fields):
 441     """Returns LVM Volumen infos using lvm_cmd
 442
 443     @param lvm_cmd: Should be one of "pvs", "vgs" or "lvs"
 444     @param fields: Fields to return
 445     @return: A list of dicts each with the parsed fields
 446
 447     """
 448     if not fields:
 449       raise errors.ProgrammerError("No fields specified")
 450
 451     sep = "|"
 452     cmd = [lvm_cmd, "--noheadings", "--nosuffix", "--units=m", "--unbuffered",
 453            "--separator=%s" % sep, "-o%s" % ",".join(fields)]
 454
 455     result = utils.RunCmd(cmd)
 456     if result.failed:
 457       raise errors.CommandError("Can't get the volume information: %s - %s" %
 458                                 (result.fail_reason, result.output))
 459
 460     data = []
 461     for line in result.stdout.splitlines():
 462       splitted_fields = line.strip().split(sep)
 463
 464       if len(fields) != len(splitted_fields):
 465         raise errors.CommandError("Can't parse %s output: line '%s'" %
 466                                   (lvm_cmd, line))
 467
 468       data.append(splitted_fields)
 469
 470     return data
 471
 472   @classmethod
 473   def GetPVInfo(cls, vg_names, filter_allocatable=True):
 474     """Get the free space info for PVs in a volume group.
 475
 476     @param vg_names: list of volume group names, if empty all will be returned
 477     @param filter_allocatable: whether to skip over unallocatable PVs
 478
 479     @rtype: list
 480     @return: list of tuples (free_space, name) with free_space in mebibytes
 481
 482     """
 483     try:
 484       info = cls._GetVolumeInfo("pvs", ["pv_name", "vg_name", "pv_free",
 485                                         "pv_attr"])
 486     except errors.GenericError, err:
 487       logging.error("Can't get PV information: %s", err)
 488       return None
 489
 490     data = []
 491     for pv_name, vg_name, pv_free, pv_attr in info:
 492       # (possibly) skip over pvs which are not allocatable
 493       if filter_allocatable and pv_attr[0] != "a":
 494         continue
 495       # (possibly) skip over pvs which are not in the right volume group(s)
 496       if vg_names and vg_name not in vg_names:
 497         continue
 498       data.append((float(pv_free), pv_name, vg_name))
 499
 500     return data
 501
 502   @classmethod
 503   def GetVGInfo(cls, vg_names, filter_readonly=True):
 504     """Get the free space info for specific VGs.
 505
 506     @param vg_names: list of volume group names, if empty all will be returned
 507     @param filter_readonly: whether to skip over readonly VGs
 508
 509     @rtype: list
 510     @return: list of tuples (free_space, total_size, name) with free_space in
 511              MiB
 512
 513     """
 514     try:
 515       info = cls._GetVolumeInfo("vgs", ["vg_name", "vg_free", "vg_attr",
 516                                         "vg_size"])
 517     except errors.GenericError, err:
 518       logging.error("Can't get VG information: %s", err)
 519       return None
 520
 521     data = []
 522     for vg_name, vg_free, vg_attr, vg_size in info:
 523       # (possibly) skip over vgs which are not writable
 524       if filter_readonly and vg_attr[0] == "r":
 525         continue
 526       # (possibly) skip over vgs which are not in the right volume group(s)
 527       if vg_names and vg_name not in vg_names:
 528         continue
 529       data.append((float(vg_free), float(vg_size), vg_name))
 530
 531     return data
 532
 533   @classmethod
 534   def _ValidateName(cls, name):
 535     """Validates that a given name is valid as VG or LV name.
 536
 537     The list of valid characters and restricted names is taken out of
 538     the lvm(8) manpage, with the simplification that we enforce both
 539     VG and LV restrictions on the names.
 540
 541     """
 542     if (not cls._VALID_NAME_RE.match(name) or
 543         name in cls._INVALID_NAMES or
 544         compat.any(substring in name for substring in cls._INVALID_SUBSTRINGS)):
 545       _ThrowError("Invalid LVM name '%s'", name)
 546
 547   def Remove(self):
 548     """Remove this logical volume.
 549
 550     """
 551     if not self.minor and not self.Attach():
 552       # the LV does not exist
 553       return
 554     result = utils.RunCmd(["lvremove", "-f", "%s/%s" %
 555                            (self._vg_name, self._lv_name)])
 556     if result.failed:
 557       _ThrowError("Can't lvremove: %s - %s", result.fail_reason, result.output)
 558
 559   def Rename(self, new_id):
 560     """Rename this logical volume.
 561
 562     """
 563     if not isinstance(new_id, (tuple, list)) or len(new_id) != 2:
 564       raise errors.ProgrammerError("Invalid new logical id '%s'" % new_id)
 565     new_vg, new_name = new_id
 566     if new_vg != self._vg_name:
 567       raise errors.ProgrammerError("Can't move a logical volume across"
 568                                    " volume groups (from %s to to %s)" %
 569                                    (self._vg_name, new_vg))
 570     result = utils.RunCmd(["lvrename", new_vg, self._lv_name, new_name])
 571     if result.failed:
 572       _ThrowError("Failed to rename the logical volume: %s", result.output)
 573     self._lv_name = new_name
 574     self.dev_path = utils.PathJoin("/dev", self._vg_name, self._lv_name)
 575
 576   def Attach(self):
 577     """Attach to an existing LV.
 578
 579     This method will try to see if an existing and active LV exists
 580     which matches our name. If so, its major/minor will be
 581     recorded.
 582
 583     """
 584     self.attached = False
 585     result = utils.RunCmd(["lvs", "--noheadings", "--separator=,",
 586                            "--units=m", "--nosuffix",
 587                            "-olv_attr,lv_kernel_major,lv_kernel_minor,"
 588                            "vg_extent_size,stripes", self.dev_path])
 589     if result.failed:
 590       logging.error("Can't find LV %s: %s, %s",
 591                     self.dev_path, result.fail_reason, result.output)
 592       return False
 593     # the output can (and will) have multiple lines for multi-segment
 594     # LVs, as the 'stripes' parameter is a segment one, so we take
 595     # only the last entry, which is the one we're interested in; note
 596     # that with LVM2 anyway the 'stripes' value must be constant
 597     # across segments, so this is a no-op actually
 598     out = result.stdout.splitlines()
 599     if not out: # totally empty result? splitlines() returns at least
 600                 # one line for any non-empty string
 601       logging.error("Can't parse LVS output, no lines? Got '%s'", str(out))
 602       return False
 603     out = out[-1].strip().rstrip(',')
 604     out = out.split(",")
 605     if len(out) != 5:
 606       logging.error("Can't parse LVS output, len(%s) != 5", str(out))
 607       return False
 608
 609     status, major, minor, pe_size, stripes = out
 610     if len(status) != 6:
 611       logging.error("lvs lv_attr is not 6 characters (%s)", status)
 612       return False
 613
 614     try:
 615       major = int(major)
 616       minor = int(minor)
 617     except (TypeError, ValueError), err:
 618       logging.error("lvs major/minor cannot be parsed: %s", str(err))
 619
 620     try:
 621       pe_size = int(float(pe_size))
 622     except (TypeError, ValueError), err:
 623       logging.error("Can't parse vg extent size: %s", err)
 624       return False
 625
 626     try:
 627       stripes = int(stripes)
 628     except (TypeError, ValueError), err:
 629       logging.error("Can't parse the number of stripes: %s", err)
 630       return False
 631
 632     self.major = major
 633     self.minor = minor
 634     self.pe_size = pe_size
 635     self.stripe_count = stripes
 636     self._degraded = status[0] == 'v' # virtual volume, i.e. doesn't backing
 637                                       # storage
 638     self.attached = True
 639     return True
 640
 641   def Assemble(self):
 642     """Assemble the device.
 643
 644     We always run `lvchange -ay` on the LV to ensure it's active before
 645     use, as there were cases when xenvg was not active after boot
 646     (also possibly after disk issues).
 647
 648     """
 649     result = utils.RunCmd(["lvchange", "-ay", self.dev_path])
 650     if result.failed:
 651       _ThrowError("Can't activate lv %s: %s", self.dev_path, result.output)
 652
 653   def Shutdown(self):
 654     """Shutdown the device.
 655
 656     This is a no-op for the LV device type, as we don't deactivate the
 657     volumes on shutdown.
 658
 659     """
 660     pass
 661
 662   def GetSyncStatus(self):
 663     """Returns the sync status of the device.
 664
 665     If this device is a mirroring device, this function returns the
 666     status of the mirror.
 667
 668     For logical volumes, sync_percent and estimated_time are always
 669     None (no recovery in progress, as we don't handle the mirrored LV
 670     case). The is_degraded parameter is the inverse of the ldisk
 671     parameter.
 672
 673     For the ldisk parameter, we check if the logical volume has the
 674     'virtual' type, which means it's not backed by existing storage
 675     anymore (read from it return I/O error). This happens after a
 676     physical disk failure and subsequent 'vgreduce --removemissing' on
 677     the volume group.
 678
 679     The status was already read in Attach, so we just return it.
 680
 681     @rtype: objects.BlockDevStatus
 682
 683     """
 684     if self._degraded:
 685       ldisk_status = constants.LDS_FAULTY
 686     else:
 687       ldisk_status = constants.LDS_OKAY
 688
 689     return objects.BlockDevStatus(dev_path=self.dev_path,
 690                                   major=self.major,
 691                                   minor=self.minor,
 692                                   sync_percent=None,
 693                                   estimated_time=None,
 694                                   is_degraded=self._degraded,
 695                                   ldisk_status=ldisk_status)
 696
 697   def Open(self, force=False):
 698     """Make the device ready for I/O.
 699
 700     This is a no-op for the LV device type.
 701
 702     """
 703     pass
 704
 705   def Close(self):
 706     """Notifies that the device will no longer be used for I/O.
 707
 708     This is a no-op for the LV device type.
 709
 710     """
 711     pass
 712
 713   def Snapshot(self, size):
 714     """Create a snapshot copy of an lvm block device.
 715
 716     @returns: tuple (vg, lv)
 717
 718     """
 719     snap_name = self._lv_name + ".snap"
 720
 721     # remove existing snapshot if found
 722     snap = LogicalVolume((self._vg_name, snap_name), None, size)
 723     _IgnoreError(snap.Remove)
 724
 725     vg_info = self.GetVGInfo([self._vg_name])
 726     if not vg_info:
 727       _ThrowError("Can't compute VG info for vg %s", self._vg_name)
 728     free_size, _, _ = vg_info[0]
 729     if free_size < size:
 730       _ThrowError("Not enough free space: required %s,"
 731                   " available %s", size, free_size)
 732
 733     result = utils.RunCmd(["lvcreate", "-L%dm" % size, "-s",
 734                            "-n%s" % snap_name, self.dev_path])
 735     if result.failed:
 736       _ThrowError("command: %s error: %s - %s",
 737                   result.cmd, result.fail_reason, result.output)
 738
 739     return (self._vg_name, snap_name)
 740
 741   def SetInfo(self, text):
 742     """Update metadata with info text.
 743
 744     """
 745     BlockDev.SetInfo(self, text)
 746
 747     # Replace invalid characters
 748     text = re.sub('^[^A-Za-z0-9_+.]', '_', text)
 749     text = re.sub('[^-A-Za-z0-9_+.]', '_', text)
 750
 751     # Only up to 128 characters are allowed
 752     text = text[:128]
 753
 754     result = utils.RunCmd(["lvchange", "--addtag", text,
 755                            self.dev_path])
 756     if result.failed:
 757       _ThrowError("Command: %s error: %s - %s", result.cmd, result.fail_reason,
 758                   result.output)
 759
 760   def Grow(self, amount, dryrun):
 761     """Grow the logical volume.
 762
 763     """
 764     if self.pe_size is None or self.stripe_count is None:
 765       if not self.Attach():
 766         _ThrowError("Can't attach to LV during Grow()")
 767     full_stripe_size = self.pe_size * self.stripe_count
 768     rest = amount % full_stripe_size
 769     if rest != 0:
 770       amount += full_stripe_size - rest
 771     cmd = ["lvextend", "-L", "+%dm" % amount]
 772     if dryrun:
 773       cmd.append("--test")
 774     # we try multiple algorithms since the 'best' ones might not have
 775     # space available in the right place, but later ones might (since
 776     # they have less constraints); also note that only recent LVM
 777     # supports 'cling'
 778     for alloc_policy in "contiguous", "cling", "normal":
 779       result = utils.RunCmd(cmd + ["--alloc", alloc_policy, self.dev_path])
 780       if not result.failed:
 781         return
 782     _ThrowError("Can't grow LV %s: %s", self.dev_path, result.output)
 783
 784
 785 class DRBD8Status(object):
 786   """A DRBD status representation class.
 787
 788   Note that this doesn't support unconfigured devices (cs:Unconfigured).
 789
 790   """
 791   UNCONF_RE = re.compile(r"\s*[0-9]+:\s*cs:Unconfigured$")
 792   LINE_RE = re.compile(r"\s*[0-9]+:\s*cs:(\S+)\s+(?:st|ro):([^/]+)/(\S+)"
 793                        "\s+ds:([^/]+)/(\S+)\s+.*$")
 794   SYNC_RE = re.compile(r"^.*\ssync'ed:\s*([0-9.]+)%.*"
 795                        "\sfinish: ([0-9]+):([0-9]+):([0-9]+)\s.*$")
 796
 797   CS_UNCONFIGURED = "Unconfigured"
 798   CS_STANDALONE = "StandAlone"
 799   CS_WFCONNECTION = "WFConnection"
 800   CS_WFREPORTPARAMS = "WFReportParams"
 801   CS_CONNECTED = "Connected"
 802   CS_STARTINGSYNCS = "StartingSyncS"
 803   CS_STARTINGSYNCT = "StartingSyncT"
 804   CS_WFBITMAPS = "WFBitMapS"
 805   CS_WFBITMAPT = "WFBitMapT"
 806   CS_WFSYNCUUID = "WFSyncUUID"
 807   CS_SYNCSOURCE = "SyncSource"
 808   CS_SYNCTARGET = "SyncTarget"
 809   CS_PAUSEDSYNCS = "PausedSyncS"
 810   CS_PAUSEDSYNCT = "PausedSyncT"
 811   CSET_SYNC = frozenset([
 812     CS_WFREPORTPARAMS,
 813     CS_STARTINGSYNCS,
 814     CS_STARTINGSYNCT,
 815     CS_WFBITMAPS,
 816     CS_WFBITMAPT,
 817     CS_WFSYNCUUID,
 818     CS_SYNCSOURCE,
 819     CS_SYNCTARGET,
 820     CS_PAUSEDSYNCS,
 821     CS_PAUSEDSYNCT,
 822     ])
 823
 824   DS_DISKLESS = "Diskless"
 825   DS_ATTACHING = "Attaching" # transient state
 826   DS_FAILED = "Failed" # transient state, next: diskless
 827   DS_NEGOTIATING = "Negotiating" # transient state
 828   DS_INCONSISTENT = "Inconsistent" # while syncing or after creation
 829   DS_OUTDATED = "Outdated"
 830   DS_DUNKNOWN = "DUnknown" # shown for peer disk when not connected
 831   DS_CONSISTENT = "Consistent"
 832   DS_UPTODATE = "UpToDate" # normal state
 833
 834   RO_PRIMARY = "Primary"
 835   RO_SECONDARY = "Secondary"
 836   RO_UNKNOWN = "Unknown"
 837
 838   def __init__(self, procline):
 839     u = self.UNCONF_RE.match(procline)
 840     if u:
 841       self.cstatus = self.CS_UNCONFIGURED
 842       self.lrole = self.rrole = self.ldisk = self.rdisk = None
 843     else:
 844       m = self.LINE_RE.match(procline)
 845       if not m:
 846         raise errors.BlockDeviceError("Can't parse input data '%s'" % procline)
 847       self.cstatus = m.group(1)
 848       self.lrole = m.group(2)
 849       self.rrole = m.group(3)
 850       self.ldisk = m.group(4)
 851       self.rdisk = m.group(5)
 852
 853     # end reading of data from the LINE_RE or UNCONF_RE
 854
 855     self.is_standalone = self.cstatus == self.CS_STANDALONE
 856     self.is_wfconn = self.cstatus == self.CS_WFCONNECTION
 857     self.is_connected = self.cstatus == self.CS_CONNECTED
 858     self.is_primary = self.lrole == self.RO_PRIMARY
 859     self.is_secondary = self.lrole == self.RO_SECONDARY
 860     self.peer_primary = self.rrole == self.RO_PRIMARY
 861     self.peer_secondary = self.rrole == self.RO_SECONDARY
 862     self.both_primary = self.is_primary and self.peer_primary
 863     self.both_secondary = self.is_secondary and self.peer_secondary
 864
 865     self.is_diskless = self.ldisk == self.DS_DISKLESS
 866     self.is_disk_uptodate = self.ldisk == self.DS_UPTODATE
 867
 868     self.is_in_resync = self.cstatus in self.CSET_SYNC
 869     self.is_in_use = self.cstatus != self.CS_UNCONFIGURED
 870
 871     m = self.SYNC_RE.match(procline)
 872     if m:
 873       self.sync_percent = float(m.group(1))
 874       hours = int(m.group(2))
 875       minutes = int(m.group(3))
 876       seconds = int(m.group(4))
 877       self.est_time = hours * 3600 + minutes * 60 + seconds
 878     else:
 879       # we have (in this if branch) no percent information, but if
 880       # we're resyncing we need to 'fake' a sync percent information,
 881       # as this is how cmdlib determines if it makes sense to wait for
 882       # resyncing or not
 883       if self.is_in_resync:
 884         self.sync_percent = 0
 885       else:
 886         self.sync_percent = None
 887       self.est_time = None
 888
 889
 890 class BaseDRBD(BlockDev): # pylint: disable-msg=W0223
 891   """Base DRBD class.
 892
 893   This class contains a few bits of common functionality between the
 894   0.7 and 8.x versions of DRBD.
 895
 896   """
 897   _VERSION_RE = re.compile(r"^version: (\d+)\.(\d+)\.(\d+)(?:\.\d+)?"
 898                            r" \(api:(\d+)/proto:(\d+)(?:-(\d+))?\)")
 899   _VALID_LINE_RE = re.compile("^ *([0-9]+): cs:([^ ]+).*$")
 900   _UNUSED_LINE_RE = re.compile("^ *([0-9]+): cs:Unconfigured$")
 901
 902   _DRBD_MAJOR = 147
 903   _ST_UNCONFIGURED = "Unconfigured"
 904   _ST_WFCONNECTION = "WFConnection"
 905   _ST_CONNECTED = "Connected"
 906
 907   _STATUS_FILE = "/proc/drbd"
 908   _USERMODE_HELPER_FILE = "/sys/module/drbd/parameters/usermode_helper"
 909
 910   @staticmethod
 911   def _GetProcData(filename=_STATUS_FILE):
 912     """Return data from /proc/drbd.
 913
 914     """
 915     try:
 916       data = utils.ReadFile(filename).splitlines()
 917     except EnvironmentError, err:
 918       if err.errno == errno.ENOENT:
 919         _ThrowError("The file %s cannot be opened, check if the module"
 920                     " is loaded (%s)", filename, str(err))
 921       else:
 922         _ThrowError("Can't read the DRBD proc file %s: %s", filename, str(err))
 923     if not data:
 924       _ThrowError("Can't read any data from %s", filename)
 925     return data
 926
 927   @classmethod
 928   def _MassageProcData(cls, data):
 929     """Transform the output of _GetProdData into a nicer form.
 930
 931     @return: a dictionary of minor: joined lines from /proc/drbd
 932         for that minor
 933
 934     """
 935     results = {}
 936     old_minor = old_line = None
 937     for line in data:
 938       if not line: # completely empty lines, as can be returned by drbd8.0+
 939         continue
 940       lresult = cls._VALID_LINE_RE.match(line)
 941       if lresult is not None:
 942         if old_minor is not None:
 943           results[old_minor] = old_line
 944         old_minor = int(lresult.group(1))
 945         old_line = line
 946       else:
 947         if old_minor is not None:
 948           old_line += " " + line.strip()
 949     # add last line
 950     if old_minor is not None:
 951       results[old_minor] = old_line
 952     return results
 953
 954   @classmethod
 955   def _GetVersion(cls, proc_data):
 956     """Return the DRBD version.
 957
 958     This will return a dict with keys:
 959       - k_major
 960       - k_minor
 961       - k_point
 962       - api
 963       - proto
 964       - proto2 (only on drbd > 8.2.X)
 965
 966     """
 967     first_line = proc_data[0].strip()
 968     version = cls._VERSION_RE.match(first_line)
 969     if not version:
 970       raise errors.BlockDeviceError("Can't parse DRBD version from '%s'" %
 971                                     first_line)
 972
 973     values = version.groups()
 974     retval = {'k_major': int(values[0]),
 975               'k_minor': int(values[1]),
 976               'k_point': int(values[2]),
 977               'api': int(values[3]),
 978               'proto': int(values[4]),
 979              }
 980     if values[5] is not None:
 981       retval['proto2'] = values[5]
 982
 983     return retval
 984
 985   @staticmethod
 986   def GetUsermodeHelper(filename=_USERMODE_HELPER_FILE):
 987     """Returns DRBD usermode_helper currently set.
 988
 989     """
 990     try:
 991       helper = utils.ReadFile(filename).splitlines()[0]
 992     except EnvironmentError, err:
 993       if err.errno == errno.ENOENT:
 994         _ThrowError("The file %s cannot be opened, check if the module"
 995                     " is loaded (%s)", filename, str(err))
 996       else:
 997         _ThrowError("Can't read DRBD helper file %s: %s", filename, str(err))
 998     if not helper:
 999       _ThrowError("Can't read any data from %s", filename)
1000     return helper
1001
1002   @staticmethod
1003   def _DevPath(minor):
1004     """Return the path to a drbd device for a given minor.
1005
1006     """
1007     return "/dev/drbd%d" % minor
1008
1009   @classmethod
1010   def GetUsedDevs(cls):
1011     """Compute the list of used DRBD devices.
1012
1013     """
1014     data = cls._GetProcData()
1015
1016     used_devs = {}
1017     for line in data:
1018       match = cls._VALID_LINE_RE.match(line)
1019       if not match:
1020         continue
1021       minor = int(match.group(1))
1022       state = match.group(2)
1023       if state == cls._ST_UNCONFIGURED:
1024         continue
1025       used_devs[minor] = state, line
1026
1027     return used_devs
1028
1029   def _SetFromMinor(self, minor):
1030     """Set our parameters based on the given minor.
1031
1032     This sets our minor variable and our dev_path.
1033
1034     """
1035     if minor is None:
1036       self.minor = self.dev_path = None
1037       self.attached = False
1038     else:
1039       self.minor = minor
1040       self.dev_path = self._DevPath(minor)
1041       self.attached = True
1042
1043   @staticmethod
1044   def _CheckMetaSize(meta_device):
1045     """Check if the given meta device looks like a valid one.
1046
1047     This currently only check the size, which must be around
1048     128MiB.
1049
1050     """
1051     result = utils.RunCmd(["blockdev", "--getsize", meta_device])
1052     if result.failed:
1053       _ThrowError("Failed to get device size: %s - %s",
1054                   result.fail_reason, result.output)
1055     try:
1056       sectors = int(result.stdout)
1057     except (TypeError, ValueError):
1058       _ThrowError("Invalid output from blockdev: '%s'", result.stdout)
1059     num_bytes = sectors * 512
1060     if num_bytes < 128 * 1024 * 1024: # less than 128MiB
1061       _ThrowError("Meta device too small (%.2fMib)", (num_bytes / 1024 / 1024))
1062     # the maximum *valid* size of the meta device when living on top
1063     # of LVM is hard to compute: it depends on the number of stripes
1064     # and the PE size; e.g. a 2-stripe, 64MB PE will result in a 128MB
1065     # (normal size), but an eight-stripe 128MB PE will result in a 1GB
1066     # size meta device; as such, we restrict it to 1GB (a little bit
1067     # too generous, but making assumptions about PE size is hard)
1068     if num_bytes > 1024 * 1024 * 1024:
1069       _ThrowError("Meta device too big (%.2fMiB)", (num_bytes / 1024 / 1024))
1070
1071   def Rename(self, new_id):
1072     """Rename a device.
1073
1074     This is not supported for drbd devices.
1075
1076     """
1077     raise errors.ProgrammerError("Can't rename a drbd device")
1078
1079
1080 class DRBD8(BaseDRBD):
1081   """DRBD v8.x block device.
1082
1083   This implements the local host part of the DRBD device, i.e. it
1084   doesn't do anything to the supposed peer. If you need a fully
1085   connected DRBD pair, you need to use this class on both hosts.
1086
1087   The unique_id for the drbd device is the (local_ip, local_port,
1088   remote_ip, remote_port) tuple, and it must have two children: the
1089   data device and the meta_device. The meta device is checked for
1090   valid size and is zeroed on create.
1091
1092   """
1093   _MAX_MINORS = 255
1094   _PARSE_SHOW = None
1095
1096   # timeout constants
1097   _NET_RECONFIG_TIMEOUT = 60
1098
1099   def __init__(self, unique_id, children, size):
1100     if children and children.count(None) > 0:
1101       children = []
1102     if len(children) not in (0, 2):
1103       raise ValueError("Invalid configuration data %s" % str(children))
1104     if not isinstance(unique_id, (tuple, list)) or len(unique_id) != 6:
1105       raise ValueError("Invalid configuration data %s" % str(unique_id))
1106     (self._lhost, self._lport,
1107      self._rhost, self._rport,
1108      self._aminor, self._secret) = unique_id
1109     if children:
1110       if not _CanReadDevice(children[1].dev_path):
1111         logging.info("drbd%s: Ignoring unreadable meta device", self._aminor)
1112         children = []
1113     super(DRBD8, self).__init__(unique_id, children, size)
1114     self.major = self._DRBD_MAJOR
1115     version = self._GetVersion(self._GetProcData())
1116     if version['k_major'] != 8 :
1117       _ThrowError("Mismatch in DRBD kernel version and requested ganeti"
1118                   " usage: kernel is %s.%s, ganeti wants 8.x",
1119                   version['k_major'], version['k_minor'])
1120
1121     if (self._lhost is not None and self._lhost == self._rhost and
1122         self._lport == self._rport):
1123       raise ValueError("Invalid configuration data, same local/remote %s" %
1124                        (unique_id,))
1125     self.Attach()
1126
1127   @classmethod
1128   def _InitMeta(cls, minor, dev_path):
1129     """Initialize a meta device.
1130
1131     This will not work if the given minor is in use.
1132
1133     """
1134     result = utils.RunCmd(["drbdmeta", "--force", cls._DevPath(minor),
1135                            "v08", dev_path, "0", "create-md"])
1136     if result.failed:
1137       _ThrowError("Can't initialize meta device: %s", result.output)
1138
1139   @classmethod
1140   def _FindUnusedMinor(cls):
1141     """Find an unused DRBD device.
1142
1143     This is specific to 8.x as the minors are allocated dynamically,
1144     so non-existing numbers up to a max minor count are actually free.
1145
1146     """
1147     data = cls._GetProcData()
1148
1149     highest = None
1150     for line in data:
1151       match = cls._UNUSED_LINE_RE.match(line)
1152       if match:
1153         return int(match.group(1))
1154       match = cls._VALID_LINE_RE.match(line)
1155       if match:
1156         minor = int(match.group(1))
1157         highest = max(highest, minor)
1158     if highest is None: # there are no minors in use at all
1159       return 0
1160     if highest >= cls._MAX_MINORS:
1161       logging.error("Error: no free drbd minors!")
1162       raise errors.BlockDeviceError("Can't find a free DRBD minor")
1163     return highest + 1
1164
1165   @classmethod
1166   def _GetShowParser(cls):
1167     """Return a parser for `drbd show` output.
1168
1169     This will either create or return an already-create parser for the
1170     output of the command `drbd show`.
1171
1172     """
1173     if cls._PARSE_SHOW is not None:
1174       return cls._PARSE_SHOW
1175
1176     # pyparsing setup
1177     lbrace = pyp.Literal("{").suppress()
1178     rbrace = pyp.Literal("}").suppress()
1179     lbracket = pyp.Literal("[").suppress()
1180     rbracket = pyp.Literal("]").suppress()
1181     semi = pyp.Literal(";").suppress()
1182     colon = pyp.Literal(":").suppress()
1183     # this also converts the value to an int
1184     number = pyp.Word(pyp.nums).setParseAction(lambda s, l, t: int(t[0]))
1185
1186     comment = pyp.Literal ("#") + pyp.Optional(pyp.restOfLine)
1187     defa = pyp.Literal("_is_default").suppress()
1188     dbl_quote = pyp.Literal('"').suppress()
1189
1190     keyword = pyp.Word(pyp.alphanums + '-')
1191
1192     # value types
1193     value = pyp.Word(pyp.alphanums + '_-/.:')
1194     quoted = dbl_quote + pyp.CharsNotIn('"') + dbl_quote
1195     ipv4_addr = (pyp.Optional(pyp.Literal("ipv4")).suppress() +
1196                  pyp.Word(pyp.nums + ".") + colon + number)
1197     ipv6_addr = (pyp.Optional(pyp.Literal("ipv6")).suppress() +
1198                  pyp.Optional(lbracket) + pyp.Word(pyp.hexnums + ":") +
1199                  pyp.Optional(rbracket) + colon + number)
1200     # meta device, extended syntax
1201     meta_value = ((value ^ quoted) + lbracket + number + rbracket)
1202     # device name, extended syntax
1203     device_value = pyp.Literal("minor").suppress() + number
1204
1205     # a statement
1206     stmt = (~rbrace + keyword + ~lbrace +
1207             pyp.Optional(ipv4_addr ^ ipv6_addr ^ value ^ quoted ^ meta_value ^
1208                          device_value) +
1209             pyp.Optional(defa) + semi +
1210             pyp.Optional(pyp.restOfLine).suppress())
1211
1212     # an entire section
1213     section_name = pyp.Word(pyp.alphas + '_')
1214     section = section_name + lbrace + pyp.ZeroOrMore(pyp.Group(stmt)) + rbrace
1215
1216     bnf = pyp.ZeroOrMore(pyp.Group(section ^ stmt))
1217     bnf.ignore(comment)
1218
1219     cls._PARSE_SHOW = bnf
1220
1221     return bnf
1222
1223   @classmethod
1224   def _GetShowData(cls, minor):
1225     """Return the `drbdsetup show` data for a minor.
1226
1227     """
1228     result = utils.RunCmd(["drbdsetup", cls._DevPath(minor), "show"])
1229     if result.failed:
1230       logging.error("Can't display the drbd config: %s - %s",
1231                     result.fail_reason, result.output)
1232       return None
1233     return result.stdout
1234
1235   @classmethod
1236   def _GetDevInfo(cls, out):
1237     """Parse details about a given DRBD minor.
1238
1239     This return, if available, the local backing device (as a path)
1240     and the local and remote (ip, port) information from a string
1241     containing the output of the `drbdsetup show` command as returned
1242     by _GetShowData.
1243
1244     """
1245     data = {}
1246     if not out:
1247       return data
1248
1249     bnf = cls._GetShowParser()
1250     # run pyparse
1251
1252     try:
1253       results = bnf.parseString(out)
1254     except pyp.ParseException, err:
1255       _ThrowError("Can't parse drbdsetup show output: %s", str(err))
1256
1257     # and massage the results into our desired format
1258     for section in results:
1259       sname = section[0]
1260       if sname == "_this_host":
1261         for lst in section[1:]:
1262           if lst[0] == "disk":
1263             data["local_dev"] = lst[1]
1264           elif lst[0] == "meta-disk":
1265             data["meta_dev"] = lst[1]
1266             data["meta_index"] = lst[2]
1267           elif lst[0] == "address":
1268             data["local_addr"] = tuple(lst[1:])
1269       elif sname == "_remote_host":
1270         for lst in section[1:]:
1271           if lst[0] == "address":
1272             data["remote_addr"] = tuple(lst[1:])
1273     return data
1274
1275   def _MatchesLocal(self, info):
1276     """Test if our local config matches with an existing device.
1277
1278     The parameter should be as returned from `_GetDevInfo()`. This
1279     method tests if our local backing device is the same as the one in
1280     the info parameter, in effect testing if we look like the given
1281     device.
1282
1283     """
1284     if self._children:
1285       backend, meta = self._children
1286     else:
1287       backend = meta = None
1288
1289     if backend is not None:
1290       retval = ("local_dev" in info and info["local_dev"] == backend.dev_path)
1291     else:
1292       retval = ("local_dev" not in info)
1293
1294     if meta is not None:
1295       retval = retval and ("meta_dev" in info and
1296                            info["meta_dev"] == meta.dev_path)
1297       retval = retval and ("meta_index" in info and
1298                            info["meta_index"] == 0)
1299     else:
1300       retval = retval and ("meta_dev" not in info and
1301                            "meta_index" not in info)
1302     return retval
1303
1304   def _MatchesNet(self, info):
1305     """Test if our network config matches with an existing device.
1306
1307     The parameter should be as returned from `_GetDevInfo()`. This
1308     method tests if our network configuration is the same as the one
1309     in the info parameter, in effect testing if we look like the given
1310     device.
1311
1312     """
1313     if (((self._lhost is None and not ("local_addr" in info)) and
1314          (self._rhost is None and not ("remote_addr" in info)))):
1315       return True
1316
1317     if self._lhost is None:
1318       return False
1319
1320     if not ("local_addr" in info and
1321             "remote_addr" in info):
1322       return False
1323
1324     retval = (info["local_addr"] == (self._lhost, self._lport))
1325     retval = (retval and
1326               info["remote_addr"] == (self._rhost, self._rport))
1327     return retval
1328
1329   @classmethod
1330   def _AssembleLocal(cls, minor, backend, meta, size):
1331     """Configure the local part of a DRBD device.
1332
1333     """
1334     args = ["drbdsetup", cls._DevPath(minor), "disk",
1335             backend, meta, "0",
1336             "-e", "detach",
1337             "--create-device"]
1338     if size:
1339       args.extend(["-d", "%sm" % size])
1340     if not constants.DRBD_BARRIERS: # disable barriers, if configured so
1341       version = cls._GetVersion(cls._GetProcData())
1342       # various DRBD versions support different disk barrier options;
1343       # what we aim here is to revert back to the 'drain' method of
1344       # disk flushes and to disable metadata barriers, in effect going
1345       # back to pre-8.0.7 behaviour
1346       vmaj = version['k_major']
1347       vmin = version['k_minor']
1348       vrel = version['k_point']
1349       assert vmaj == 8
1350       if vmin == 0: # 8.0.x
1351         if vrel >= 12:
1352           args.extend(['-i', '-m'])
1353       elif vmin == 2: # 8.2.x
1354         if vrel >= 7:
1355           args.extend(['-i', '-m'])
1356       elif vmaj >= 3: # 8.3.x or newer
1357         args.extend(['-i', '-a', 'm'])
1358     result = utils.RunCmd(args)
1359     if result.failed:
1360       _ThrowError("drbd%d: can't attach local disk: %s", minor, result.output)
1361
1362   @classmethod
1363   def _AssembleNet(cls, minor, net_info, protocol,
1364                    dual_pri=False, hmac=None, secret=None):
1365     """Configure the network part of the device.
1366
1367     """
1368     lhost, lport, rhost, rport = net_info
1369     if None in net_info:
1370       # we don't want network connection and actually want to make
1371       # sure its shutdown
1372       cls._ShutdownNet(minor)
1373       return
1374
1375     # Workaround for a race condition. When DRBD is doing its dance to
1376     # establish a connection with its peer, it also sends the
1377     # synchronization speed over the wire. In some cases setting the
1378     # sync speed only after setting up both sides can race with DRBD
1379     # connecting, hence we set it here before telling DRBD anything
1380     # about its peer.
1381     cls._SetMinorSyncSpeed(minor, constants.SYNC_SPEED)
1382
1383     if netutils.IP6Address.IsValid(lhost):
1384       if not netutils.IP6Address.IsValid(rhost):
1385         _ThrowError("drbd%d: can't connect ip %s to ip %s" %
1386                     (minor, lhost, rhost))
1387       family = "ipv6"
1388     elif netutils.IP4Address.IsValid(lhost):
1389       if not netutils.IP4Address.IsValid(rhost):
1390         _ThrowError("drbd%d: can't connect ip %s to ip %s" %
1391                     (minor, lhost, rhost))
1392       family = "ipv4"
1393     else:
1394       _ThrowError("drbd%d: Invalid ip %s" % (minor, lhost))
1395
1396     args = ["drbdsetup", cls._DevPath(minor), "net",
1397             "%s:%s:%s" % (family, lhost, lport),
1398             "%s:%s:%s" % (family, rhost, rport), protocol,
1399             "-A", "discard-zero-changes",
1400             "-B", "consensus",
1401             "--create-device",
1402             ]
1403     if dual_pri:
1404       args.append("-m")
1405     if hmac and secret:
1406       args.extend(["-a", hmac, "-x", secret])
1407     result = utils.RunCmd(args)
1408     if result.failed:
1409       _ThrowError("drbd%d: can't setup network: %s - %s",
1410                   minor, result.fail_reason, result.output)
1411
1412     def _CheckNetworkConfig():
1413       info = cls._GetDevInfo(cls._GetShowData(minor))
1414       if not "local_addr" in info or not "remote_addr" in info:
1415         raise utils.RetryAgain()
1416
1417       if (info["local_addr"] != (lhost, lport) or
1418           info["remote_addr"] != (rhost, rport)):
1419         raise utils.RetryAgain()
1420
1421     try:
1422       utils.Retry(_CheckNetworkConfig, 1.0, 10.0)
1423     except utils.RetryTimeout:
1424       _ThrowError("drbd%d: timeout while configuring network", minor)
1425
1426   def AddChildren(self, devices):
1427     """Add a disk to the DRBD device.
1428
1429     """
1430     if self.minor is None:
1431       _ThrowError("drbd%d: can't attach to dbrd8 during AddChildren",
1432                   self._aminor)
1433     if len(devices) != 2:
1434       _ThrowError("drbd%d: need two devices for AddChildren", self.minor)
1435     info = self._GetDevInfo(self._GetShowData(self.minor))
1436     if "local_dev" in info:
1437       _ThrowError("drbd%d: already attached to a local disk", self.minor)
1438     backend, meta = devices
1439     if backend.dev_path is None or meta.dev_path is None:
1440       _ThrowError("drbd%d: children not ready during AddChildren", self.minor)
1441     backend.Open()
1442     meta.Open()
1443     self._CheckMetaSize(meta.dev_path)
1444     self._InitMeta(self._FindUnusedMinor(), meta.dev_path)
1445
1446     self._AssembleLocal(self.minor, backend.dev_path, meta.dev_path, self.size)
1447     self._children = devices
1448
1449   def RemoveChildren(self, devices):
1450     """Detach the drbd device from local storage.
1451
1452     """
1453     if self.minor is None:
1454       _ThrowError("drbd%d: can't attach to drbd8 during RemoveChildren",
1455                   self._aminor)
1456     # early return if we don't actually have backing storage
1457     info = self._GetDevInfo(self._GetShowData(self.minor))
1458     if "local_dev" not in info:
1459       return
1460     if len(self._children) != 2:
1461       _ThrowError("drbd%d: we don't have two children: %s", self.minor,
1462                   self._children)
1463     if self._children.count(None) == 2: # we don't actually have children :)
1464       logging.warning("drbd%d: requested detach while detached", self.minor)
1465       return
1466     if len(devices) != 2:
1467       _ThrowError("drbd%d: we need two children in RemoveChildren", self.minor)
1468     for child, dev in zip(self._children, devices):
1469       if dev != child.dev_path:
1470         _ThrowError("drbd%d: mismatch in local storage (%s != %s) in"
1471                     " RemoveChildren", self.minor, dev, child.dev_path)
1472
1473     self._ShutdownLocal(self.minor)
1474     self._children = []
1475
1476   @classmethod
1477   def _SetMinorSyncSpeed(cls, minor, kbytes):
1478     """Set the speed of the DRBD syncer.
1479
1480     This is the low-level implementation.
1481
1482     @type minor: int
1483     @param minor: the drbd minor whose settings we change
1484     @type kbytes: int
1485     @param kbytes: the speed in kbytes/second
1486     @rtype: boolean
1487     @return: the success of the operation
1488
1489     """
1490     result = utils.RunCmd(["drbdsetup", cls._DevPath(minor), "syncer",
1491                            "-r", "%d" % kbytes, "--create-device"])
1492     if result.failed:
1493       logging.error("Can't change syncer rate: %s - %s",
1494                     result.fail_reason, result.output)
1495     return not result.failed
1496
1497   def SetSyncSpeed(self, kbytes):
1498     """Set the speed of the DRBD syncer.
1499
1500     @type kbytes: int
1501     @param kbytes: the speed in kbytes/second
1502     @rtype: boolean
1503     @return: the success of the operation
1504
1505     """
1506     if self.minor is None:
1507       logging.info("Not attached during SetSyncSpeed")
1508       return False
1509     children_result = super(DRBD8, self).SetSyncSpeed(kbytes)
1510     return self._SetMinorSyncSpeed(self.minor, kbytes) and children_result
1511
1512   def PauseResumeSync(self, pause):
1513     """Pauses or resumes the sync of a DRBD device.
1514
1515     @param pause: Wether to pause or resume
1516     @return: the success of the operation
1517
1518     """
1519     if self.minor is None:
1520       logging.info("Not attached during PauseSync")
1521       return False
1522
1523     children_result = super(DRBD8, self).PauseResumeSync(pause)
1524
1525     if pause:
1526       cmd = "pause-sync"
1527     else:
1528       cmd = "resume-sync"
1529
1530     result = utils.RunCmd(["drbdsetup", self.dev_path, cmd])
1531     if result.failed:
1532       logging.error("Can't %s: %s - %s", cmd,
1533                     result.fail_reason, result.output)
1534     return not result.failed and children_result
1535
1536   def GetProcStatus(self):
1537     """Return device data from /proc.
1538
1539     """
1540     if self.minor is None:
1541       _ThrowError("drbd%d: GetStats() called while not attached", self._aminor)
1542     proc_info = self._MassageProcData(self._GetProcData())
1543     if self.minor not in proc_info:
1544       _ThrowError("drbd%d: can't find myself in /proc", self.minor)
1545     return DRBD8Status(proc_info[self.minor])
1546
1547   def GetSyncStatus(self):
1548     """Returns the sync status of the device.
1549
1550
1551     If sync_percent is None, it means all is ok
1552     If estimated_time is None, it means we can't estimate
1553     the time needed, otherwise it's the time left in seconds.
1554
1555
1556     We set the is_degraded parameter to True on two conditions:
1557     network not connected or local disk missing.
1558
1559     We compute the ldisk parameter based on whether we have a local
1560     disk or not.
1561
1562     @rtype: objects.BlockDevStatus
1563
1564     """
1565     if self.minor is None and not self.Attach():
1566       _ThrowError("drbd%d: can't Attach() in GetSyncStatus", self._aminor)
1567
1568     stats = self.GetProcStatus()
1569     is_degraded = not stats.is_connected or not stats.is_disk_uptodate
1570
1571     if stats.is_disk_uptodate:
1572       ldisk_status = constants.LDS_OKAY
1573     elif stats.is_diskless:
1574       ldisk_status = constants.LDS_FAULTY
1575     else:
1576       ldisk_status = constants.LDS_UNKNOWN
1577
1578     return objects.BlockDevStatus(dev_path=self.dev_path,
1579                                   major=self.major,
1580                                   minor=self.minor,
1581                                   sync_percent=stats.sync_percent,
1582                                   estimated_time=stats.est_time,
1583                                   is_degraded=is_degraded,
1584                                   ldisk_status=ldisk_status)
1585
1586   def Open(self, force=False):
1587     """Make the local state primary.
1588
1589     If the 'force' parameter is given, the '-o' option is passed to
1590     drbdsetup. Since this is a potentially dangerous operation, the
1591     force flag should be only given after creation, when it actually
1592     is mandatory.
1593
1594     """
1595     if self.minor is None and not self.Attach():
1596       logging.error("DRBD cannot attach to a device during open")
1597       return False
1598     cmd = ["drbdsetup", self.dev_path, "primary"]
1599     if force:
1600       cmd.append("-o")
1601     result = utils.RunCmd(cmd)
1602     if result.failed:
1603       _ThrowError("drbd%d: can't make drbd device primary: %s", self.minor,
1604                   result.output)
1605
1606   def Close(self):
1607     """Make the local state secondary.
1608
1609     This will, of course, fail if the device is in use.
1610
1611     """
1612     if self.minor is None and not self.Attach():
1613       _ThrowError("drbd%d: can't Attach() in Close()", self._aminor)
1614     result = utils.RunCmd(["drbdsetup", self.dev_path, "secondary"])
1615     if result.failed:
1616       _ThrowError("drbd%d: can't switch drbd device to secondary: %s",
1617                   self.minor, result.output)
1618
1619   def DisconnectNet(self):
1620     """Removes network configuration.
1621
1622     This method shutdowns the network side of the device.
1623
1624     The method will wait up to a hardcoded timeout for the device to
1625     go into standalone after the 'disconnect' command before
1626     re-configuring it, as sometimes it takes a while for the
1627     disconnect to actually propagate and thus we might issue a 'net'
1628     command while the device is still connected. If the device will
1629     still be attached to the network and we time out, we raise an
1630     exception.
1631
1632     """
1633     if self.minor is None:
1634       _ThrowError("drbd%d: disk not attached in re-attach net", self._aminor)
1635
1636     if None in (self._lhost, self._lport, self._rhost, self._rport):
1637       _ThrowError("drbd%d: DRBD disk missing network info in"
1638                   " DisconnectNet()", self.minor)
1639
1640     class _DisconnectStatus:
1641       def __init__(self, ever_disconnected):
1642         self.ever_disconnected = ever_disconnected
1643
1644     dstatus = _DisconnectStatus(_IgnoreError(self._ShutdownNet, self.minor))
1645
1646     def _WaitForDisconnect():
1647       if self.GetProcStatus().is_standalone:
1648         return
1649
1650       # retry the disconnect, it seems possible that due to a well-time
1651       # disconnect on the peer, my disconnect command might be ignored and
1652       # forgotten
1653       dstatus.ever_disconnected = \
1654         _IgnoreError(self._ShutdownNet, self.minor) or dstatus.ever_disconnected
1655
1656       raise utils.RetryAgain()
1657
1658     # Keep start time
1659     start_time = time.time()
1660
1661     try:
1662       # Start delay at 100 milliseconds and grow up to 2 seconds
1663       utils.Retry(_WaitForDisconnect, (0.1, 1.5, 2.0),
1664                   self._NET_RECONFIG_TIMEOUT)
1665     except utils.RetryTimeout:
1666       if dstatus.ever_disconnected:
1667         msg = ("drbd%d: device did not react to the"
1668                " 'disconnect' command in a timely manner")
1669       else:
1670         msg = "drbd%d: can't shutdown network, even after multiple retries"
1671
1672       _ThrowError(msg, self.minor)
1673
1674     reconfig_time = time.time() - start_time
1675     if reconfig_time > (self._NET_RECONFIG_TIMEOUT * 0.25):
1676       logging.info("drbd%d: DisconnectNet: detach took %.3f seconds",
1677                    self.minor, reconfig_time)
1678
1679   def AttachNet(self, multimaster):
1680     """Reconnects the network.
1681
1682     This method connects the network side of the device with a
1683     specified multi-master flag. The device needs to be 'Standalone'
1684     but have valid network configuration data.
1685
1686     Args:
1687       - multimaster: init the network in dual-primary mode
1688
1689     """
1690     if self.minor is None:
1691       _ThrowError("drbd%d: device not attached in AttachNet", self._aminor)
1692
1693     if None in (self._lhost, self._lport, self._rhost, self._rport):
1694       _ThrowError("drbd%d: missing network info in AttachNet()", self.minor)
1695
1696     status = self.GetProcStatus()
1697
1698     if not status.is_standalone:
1699       _ThrowError("drbd%d: device is not standalone in AttachNet", self.minor)
1700
1701     self._AssembleNet(self.minor,
1702                       (self._lhost, self._lport, self._rhost, self._rport),
1703                       constants.DRBD_NET_PROTOCOL, dual_pri=multimaster,
1704                       hmac=constants.DRBD_HMAC_ALG, secret=self._secret)
1705
1706   def Attach(self):
1707     """Check if our minor is configured.
1708
1709     This doesn't do any device configurations - it only checks if the
1710     minor is in a state different from Unconfigured.
1711
1712     Note that this function will not change the state of the system in
1713     any way (except in case of side-effects caused by reading from
1714     /proc).
1715
1716     """
1717     used_devs = self.GetUsedDevs()
1718     if self._aminor in used_devs:
1719       minor = self._aminor
1720     else:
1721       minor = None
1722
1723     self._SetFromMinor(minor)
1724     return minor is not None
1725
1726   def Assemble(self):
1727     """Assemble the drbd.
1728
1729     Method:
1730       - if we have a configured device, we try to ensure that it matches
1731         our config
1732       - if not, we create it from zero
1733
1734     """
1735     super(DRBD8, self).Assemble()
1736
1737     self.Attach()
1738     if self.minor is None:
1739       # local device completely unconfigured
1740       self._FastAssemble()
1741     else:
1742       # we have to recheck the local and network status and try to fix
1743       # the device
1744       self._SlowAssemble()
1745
1746   def _SlowAssemble(self):
1747     """Assembles the DRBD device from a (partially) configured device.
1748
1749     In case of partially attached (local device matches but no network
1750     setup), we perform the network attach. If successful, we re-test
1751     the attach if can return success.
1752
1753     """
1754     # TODO: Rewrite to not use a for loop just because there is 'break'
1755     # pylint: disable-msg=W0631
1756     net_data = (self._lhost, self._lport, self._rhost, self._rport)
1757     for minor in (self._aminor,):
1758       info = self._GetDevInfo(self._GetShowData(minor))
1759       match_l = self._MatchesLocal(info)
1760       match_r = self._MatchesNet(info)
1761
1762       if match_l and match_r:
1763         # everything matches
1764         break
1765
1766       if match_l and not match_r and "local_addr" not in info:
1767         # disk matches, but not attached to network, attach and recheck
1768         self._AssembleNet(minor, net_data, constants.DRBD_NET_PROTOCOL,
1769                           hmac=constants.DRBD_HMAC_ALG, secret=self._secret)
1770         if self._MatchesNet(self._GetDevInfo(self._GetShowData(minor))):
1771           break
1772         else:
1773           _ThrowError("drbd%d: network attach successful, but 'drbdsetup"
1774                       " show' disagrees", minor)
1775
1776       if match_r and "local_dev" not in info:
1777         # no local disk, but network attached and it matches
1778         self._AssembleLocal(minor, self._children[0].dev_path,
1779                             self._children[1].dev_path, self.size)
1780         if self._MatchesNet(self._GetDevInfo(self._GetShowData(minor))):
1781           break
1782         else:
1783           _ThrowError("drbd%d: disk attach successful, but 'drbdsetup"
1784                       " show' disagrees", minor)
1785
1786       # this case must be considered only if we actually have local
1787       # storage, i.e. not in diskless mode, because all diskless
1788       # devices are equal from the point of view of local
1789       # configuration
1790       if (match_l and "local_dev" in info and
1791           not match_r and "local_addr" in info):
1792         # strange case - the device network part points to somewhere
1793         # else, even though its local storage is ours; as we own the
1794         # drbd space, we try to disconnect from the remote peer and
1795         # reconnect to our correct one
1796         try:
1797           self._ShutdownNet(minor)
1798         except errors.BlockDeviceError, err:
1799           _ThrowError("drbd%d: device has correct local storage, wrong"
1800                       " remote peer and is unable to disconnect in order"
1801                       " to attach to the correct peer: %s", minor, str(err))
1802         # note: _AssembleNet also handles the case when we don't want
1803         # local storage (i.e. one or more of the _[lr](host|port) is
1804         # None)
1805         self._AssembleNet(minor, net_data, constants.DRBD_NET_PROTOCOL,
1806                           hmac=constants.DRBD_HMAC_ALG, secret=self._secret)
1807         if self._MatchesNet(self._GetDevInfo(self._GetShowData(minor))):
1808           break
1809         else:
1810           _ThrowError("drbd%d: network attach successful, but 'drbdsetup"
1811                       " show' disagrees", minor)
1812
1813     else:
1814       minor = None
1815
1816     self._SetFromMinor(minor)
1817     if minor is None:
1818       _ThrowError("drbd%d: cannot activate, unknown or unhandled reason",
1819                   self._aminor)
1820
1821   def _FastAssemble(self):
1822     """Assemble the drbd device from zero.
1823
1824     This is run when in Assemble we detect our minor is unused.
1825
1826     """
1827     minor = self._aminor
1828     if self._children and self._children[0] and self._children[1]:
1829       self._AssembleLocal(minor, self._children[0].dev_path,
1830                           self._children[1].dev_path, self.size)
1831     if self._lhost and self._lport and self._rhost and self._rport:
1832       self._AssembleNet(minor,
1833                         (self._lhost, self._lport, self._rhost, self._rport),
1834                         constants.DRBD_NET_PROTOCOL,
1835                         hmac=constants.DRBD_HMAC_ALG, secret=self._secret)
1836     self._SetFromMinor(minor)
1837
1838   @classmethod
1839   def _ShutdownLocal(cls, minor):
1840     """Detach from the local device.
1841
1842     I/Os will continue to be served from the remote device. If we
1843     don't have a remote device, this operation will fail.
1844
1845     """
1846     result = utils.RunCmd(["drbdsetup", cls._DevPath(minor), "detach"])
1847     if result.failed:
1848       _ThrowError("drbd%d: can't detach local disk: %s", minor, result.output)
1849
1850   @classmethod
1851   def _ShutdownNet(cls, minor):
1852     """Disconnect from the remote peer.
1853
1854     This fails if we don't have a local device.
1855
1856     """
1857     result = utils.RunCmd(["drbdsetup", cls._DevPath(minor), "disconnect"])
1858     if result.failed:
1859       _ThrowError("drbd%d: can't shutdown network: %s", minor, result.output)
1860
1861   @classmethod
1862   def _ShutdownAll(cls, minor):
1863     """Deactivate the device.
1864
1865     This will, of course, fail if the device is in use.
1866
1867     """
1868     result = utils.RunCmd(["drbdsetup", cls._DevPath(minor), "down"])
1869     if result.failed:
1870       _ThrowError("drbd%d: can't shutdown drbd device: %s",
1871                   minor, result.output)
1872
1873   def Shutdown(self):
1874     """Shutdown the DRBD device.
1875
1876     """
1877     if self.minor is None and not self.Attach():
1878       logging.info("drbd%d: not attached during Shutdown()", self._aminor)
1879       return
1880     minor = self.minor
1881     self.minor = None
1882     self.dev_path = None
1883     self._ShutdownAll(minor)
1884
1885   def Remove(self):
1886     """Stub remove for DRBD devices.
1887
1888     """
1889     self.Shutdown()
1890
1891   @classmethod
1892   def Create(cls, unique_id, children, size):
1893     """Create a new DRBD8 device.
1894
1895     Since DRBD devices are not created per se, just assembled, this
1896     function only initializes the metadata.
1897
1898     """
1899     if len(children) != 2:
1900       raise errors.ProgrammerError("Invalid setup for the drbd device")
1901     # check that the minor is unused
1902     aminor = unique_id[4]
1903     proc_info = cls._MassageProcData(cls._GetProcData())
1904     if aminor in proc_info:
1905       status = DRBD8Status(proc_info[aminor])
1906       in_use = status.is_in_use
1907     else:
1908       in_use = False
1909     if in_use:
1910       _ThrowError("drbd%d: minor is already in use at Create() time", aminor)
1911     meta = children[1]
1912     meta.Assemble()
1913     if not meta.Attach():
1914       _ThrowError("drbd%d: can't attach to meta device '%s'",
1915                   aminor, meta)
1916     cls._CheckMetaSize(meta.dev_path)
1917     cls._InitMeta(aminor, meta.dev_path)
1918     return cls(unique_id, children, size)
1919
1920   def Grow(self, amount, dryrun):
1921     """Resize the DRBD device and its backing storage.
1922
1923     """
1924     if self.minor is None:
1925       _ThrowError("drbd%d: Grow called while not attached", self._aminor)
1926     if len(self._children) != 2 or None in self._children:
1927       _ThrowError("drbd%d: cannot grow diskless device", self.minor)
1928     self._children[0].Grow(amount, dryrun)
1929     if dryrun:
1930       # DRBD does not support dry-run mode, so we'll return here
1931       return
1932     result = utils.RunCmd(["drbdsetup", self.dev_path, "resize", "-s",
1933                            "%dm" % (self.size + amount)])
1934     if result.failed:
1935       _ThrowError("drbd%d: resize failed: %s", self.minor, result.output)
1936
1937
1938 class FileStorage(BlockDev):
1939   """File device.
1940
1941   This class represents the a file storage backend device.
1942
1943   The unique_id for the file device is a (file_driver, file_path) tuple.
1944
1945   """
1946   def __init__(self, unique_id, children, size):
1947     """Initalizes a file device backend.
1948
1949     """
1950     if children:
1951       raise errors.BlockDeviceError("Invalid setup for file device")
1952     super(FileStorage, self).__init__(unique_id, children, size)
1953     if not isinstance(unique_id, (tuple, list)) or len(unique_id) != 2:
1954       raise ValueError("Invalid configuration data %s" % str(unique_id))
1955     self.driver = unique_id[0]
1956     self.dev_path = unique_id[1]
1957     self.Attach()
1958
1959   def Assemble(self):
1960     """Assemble the device.
1961
1962     Checks whether the file device exists, raises BlockDeviceError otherwise.
1963
1964     """
1965     if not os.path.exists(self.dev_path):
1966       _ThrowError("File device '%s' does not exist" % self.dev_path)
1967
1968   def Shutdown(self):
1969     """Shutdown the device.
1970
1971     This is a no-op for the file type, as we don't deactivate
1972     the file on shutdown.
1973
1974     """
1975     pass
1976
1977   def Open(self, force=False):
1978     """Make the device ready for I/O.
1979
1980     This is a no-op for the file type.
1981
1982     """
1983     pass
1984
1985   def Close(self):
1986     """Notifies that the device will no longer be used for I/O.
1987
1988     This is a no-op for the file type.
1989
1990     """
1991     pass
1992
1993   def Remove(self):
1994     """Remove the file backing the block device.
1995
1996     @rtype: boolean
1997     @return: True if the removal was successful
1998
1999     """
2000     try:
2001       os.remove(self.dev_path)
2002     except OSError, err:
2003       if err.errno != errno.ENOENT:
2004         _ThrowError("Can't remove file '%s': %s", self.dev_path, err)
2005
2006   def Rename(self, new_id):
2007     """Renames the file.
2008
2009     """
2010     # TODO: implement rename for file-based storage
2011     _ThrowError("Rename is not supported for file-based storage")
2012
2013   def Grow(self, amount, dryrun):
2014     """Grow the file
2015
2016     @param amount: the amount (in mebibytes) to grow with
2017
2018     """
2019     # Check that the file exists
2020     self.Assemble()
2021     current_size = self.GetActualSize()
2022     new_size = current_size + amount * 1024 * 1024
2023     assert new_size > current_size, "Cannot Grow with a negative amount"
2024     # We can't really simulate the growth
2025     if dryrun:
2026       return
2027     try:
2028       f = open(self.dev_path, "a+")
2029       f.truncate(new_size)
2030       f.close()
2031     except EnvironmentError, err:
2032       _ThrowError("Error in file growth: %", str(err))
2033
2034   def Attach(self):
2035     """Attach to an existing file.
2036
2037     Check if this file already exists.
2038
2039     @rtype: boolean
2040     @return: True if file exists
2041
2042     """
2043     self.attached = os.path.exists(self.dev_path)
2044     return self.attached
2045
2046   def GetActualSize(self):
2047     """Return the actual disk size.
2048
2049     @note: the device needs to be active when this is called
2050
2051     """
2052     assert self.attached, "BlockDevice not attached in GetActualSize()"
2053     try:
2054       st = os.stat(self.dev_path)
2055       return st.st_size
2056     except OSError, err:
2057       _ThrowError("Can't stat %s: %s", self.dev_path, err)
2058
2059   @classmethod
2060   def Create(cls, unique_id, children, size):
2061     """Create a new file.
2062
2063     @param size: the size of file in MiB
2064
2065     @rtype: L{bdev.FileStorage}
2066     @return: an instance of FileStorage
2067
2068     """
2069     if not isinstance(unique_id, (tuple, list)) or len(unique_id) != 2:
2070       raise ValueError("Invalid configuration data %s" % str(unique_id))
2071     dev_path = unique_id[1]
2072     try:
2073       fd = os.open(dev_path, os.O_RDWR | os.O_CREAT | os.O_EXCL)
2074       f = os.fdopen(fd, "w")
2075       f.truncate(size * 1024 * 1024)
2076       f.close()
2077     except EnvironmentError, err:
2078       if err.errno == errno.EEXIST:
2079         _ThrowError("File already existing: %s", dev_path)
2080       _ThrowError("Error in file creation: %", str(err))
2081
2082     return FileStorage(unique_id, children, size)
2083
2084
2085 class PersistentBlockDevice(BlockDev):
2086   """A block device with persistent node
2087
2088   May be either directly attached, or exposed through DM (e.g. dm-multipath).
2089   udev helpers are probably required to give persistent, human-friendly
2090   names.
2091
2092   For the time being, pathnames are required to lie under /dev.
2093
2094   """
2095   def __init__(self, unique_id, children, size):
2096     """Attaches to a static block device.
2097
2098     The unique_id is a path under /dev.
2099
2100     """
2101     super(PersistentBlockDevice, self).__init__(unique_id, children, size)
2102     if not isinstance(unique_id, (tuple, list)) or len(unique_id) != 2:
2103       raise ValueError("Invalid configuration data %s" % str(unique_id))
2104     self.dev_path = unique_id[1]
2105     if not os.path.realpath(self.dev_path).startswith('/dev/'):
2106       raise ValueError("Full path '%s' lies outside /dev" %
2107                               os.path.realpath(self.dev_path))
2108     # TODO: this is just a safety guard checking that we only deal with devices
2109     # we know how to handle. In the future this will be integrated with
2110     # external storage backends and possible values will probably be collected
2111     # from the cluster configuration.
2112     if unique_id[0] != constants.BLOCKDEV_DRIVER_MANUAL:
2113       raise ValueError("Got persistent block device of invalid type: %s" %
2114                        unique_id[0])
2115
2116     self.major = self.minor = None
2117     self.Attach()
2118
2119   @classmethod
2120   def Create(cls, unique_id, children, size):
2121     """Create a new device
2122
2123     This is a noop, we only return a PersistentBlockDevice instance
2124
2125     """
2126     return PersistentBlockDevice(unique_id, children, 0)
2127
2128   def Remove(self):
2129     """Remove a device
2130
2131     This is a noop
2132
2133     """
2134     pass
2135
2136   def Rename(self, new_id):
2137     """Rename this device.
2138
2139     """
2140     _ThrowError("Rename is not supported for PersistentBlockDev storage")
2141
2142   def Attach(self):
2143     """Attach to an existing block device.
2144
2145
2146     """
2147     self.attached = False
2148     try:
2149       st = os.stat(self.dev_path)
2150     except OSError, err:
2151       logging.error("Error stat()'ing %s: %s", self.dev_path, str(err))
2152       return False
2153
2154     if not stat.S_ISBLK(st.st_mode):
2155       logging.error("%s is not a block device", self.dev_path)
2156       return False
2157
2158     self.major = os.major(st.st_rdev)
2159     self.minor = os.minor(st.st_rdev)
2160     self.attached = True
2161
2162     return True
2163
2164   def Assemble(self):
2165     """Assemble the device.
2166
2167     """
2168     pass
2169
2170   def Shutdown(self):
2171     """Shutdown the device.
2172
2173     """
2174     pass
2175
2176   def Open(self, force=False):
2177     """Make the device ready for I/O.
2178
2179     """
2180     pass
2181
2182   def Close(self):
2183     """Notifies that the device will no longer be used for I/O.
2184
2185     """
2186     pass
2187
2188   def Grow(self, amount, dryrun):
2189     """Grow the logical volume.
2190
2191     """
2192     _ThrowError("Grow is not supported for PersistentBlockDev storage")
2193
2194
2195 DEV_MAP = {
2196   constants.LD_LV: LogicalVolume,
2197   constants.LD_DRBD8: DRBD8,
2198   constants.LD_BLOCKDEV: PersistentBlockDevice,
2199   }
2200
2201 if constants.ENABLE_FILE_STORAGE or constants.ENABLE_SHARED_FILE_STORAGE:
2202   DEV_MAP[constants.LD_FILE] = FileStorage
2203
2204
2205 def FindDevice(dev_type, unique_id, children, size):
2206   """Search for an existing, assembled device.
2207
2208   This will succeed only if the device exists and is assembled, but it
2209   does not do any actions in order to activate the device.
2210
2211   """
2212   if dev_type not in DEV_MAP:
2213     raise errors.ProgrammerError("Invalid block device type '%s'" % dev_type)
2214   device = DEV_MAP[dev_type](unique_id, children, size)
2215   if not device.attached:
2216     return None
2217   return device
2218
2219
2220 def Assemble(dev_type, unique_id, children, size):
2221   """Try to attach or assemble an existing device.
2222
2223   This will attach to assemble the device, as needed, to bring it
2224   fully up. It must be safe to run on already-assembled devices.
2225
2226   """
2227   if dev_type not in DEV_MAP:
2228     raise errors.ProgrammerError("Invalid block device type '%s'" % dev_type)
2229   device = DEV_MAP[dev_type](unique_id, children, size)
2230   device.Assemble()
2231   return device
2232
2233
2234 def Create(dev_type, unique_id, children, size):
2235   """Create a device.
2236
2237   """
2238   if dev_type not in DEV_MAP:
2239     raise errors.ProgrammerError("Invalid block device type '%s'" % dev_type)
2240   device = DEV_MAP[dev_type].Create(unique_id, children, size)
2241   return device