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

   1 #
   2 #
   3
   4 # Copyright (C) 2006, 2007, 2010, 2011, 2012, 2013 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 """DRBD block device related functionality"""
  23
  24 import errno
  25 import logging
  26 import time
  27
  28 from ganeti import constants
  29 from ganeti import utils
  30 from ganeti import errors
  31 from ganeti import netutils
  32 from ganeti import objects
  33 from ganeti.storage import base
  34 from ganeti.storage.drbd_info import DRBD8Info
  35 from ganeti.storage import drbd_info
  36 from ganeti.storage import drbd_cmdgen
  37
  38
  39 # Size of reads in _CanReadDevice
  40
  41 _DEVICE_READ_SIZE = 128 * 1024
  42
  43
  44 class DRBD8(object):
  45   """Various methods to deals with the DRBD system as a whole.
  46
  47   This class provides a set of methods to deal with the DRBD installation on
  48   the node or with uninitialized devices as opposed to a DRBD device.
  49
  50   """
  51   _USERMODE_HELPER_FILE = "/sys/module/drbd/parameters/usermode_helper"
  52
  53   _MAX_MINORS = 255
  54
  55   @staticmethod
  56   def GetUsermodeHelper(filename=_USERMODE_HELPER_FILE):
  57     """Returns DRBD usermode_helper currently set.
  58
  59     @type filename: string
  60     @param filename: the filename to read the usermode helper from
  61     @rtype: string
  62     @return: the currently configured DRBD usermode helper
  63
  64     """
  65     try:
  66       helper = utils.ReadFile(filename).splitlines()[0]
  67     except EnvironmentError, err:
  68       if err.errno == errno.ENOENT:
  69         base.ThrowError("The file %s cannot be opened, check if the module"
  70                         " is loaded (%s)", filename, str(err))
  71       else:
  72         base.ThrowError("Can't read DRBD helper file %s: %s",
  73                         filename, str(err))
  74     if not helper:
  75       base.ThrowError("Can't read any data from %s", filename)
  76     return helper
  77
  78   @staticmethod
  79   def GetProcInfo():
  80     """Reads and parses information from /proc/drbd.
  81
  82     @rtype: DRBD8Info
  83     @return: a L{DRBD8Info} instance containing the current /proc/drbd info
  84
  85     """
  86     return DRBD8Info.CreateFromFile()
  87
  88   @staticmethod
  89   def GetUsedDevs():
  90     """Compute the list of used DRBD minors.
  91
  92     @rtype: list of ints
  93
  94     """
  95     info = DRBD8.GetProcInfo()
  96     return filter(lambda m: not info.GetMinorStatus(m).is_unconfigured,
  97                   info.GetMinors())
  98
  99   @staticmethod
 100   def FindUnusedMinor():
 101     """Find an unused DRBD device.
 102
 103     This is specific to 8.x as the minors are allocated dynamically,
 104     so non-existing numbers up to a max minor count are actually free.
 105
 106     @rtype: int
 107
 108     """
 109     highest = None
 110     info = DRBD8.GetProcInfo()
 111     for minor in info.GetMinors():
 112       status = info.GetMinorStatus(minor)
 113       if not status.is_in_use:
 114         return minor
 115       highest = max(highest, minor)
 116
 117     if highest is None: # there are no minors in use at all
 118       return 0
 119     if highest >= DRBD8._MAX_MINORS:
 120       logging.error("Error: no free drbd minors!")
 121       raise errors.BlockDeviceError("Can't find a free DRBD minor")
 122
 123     return highest + 1
 124
 125   @staticmethod
 126   def GetCmdGenerator(info):
 127     """Creates a suitable L{BaseDRBDCmdGenerator} based on the given info.
 128
 129     @type info: DRBD8Info
 130     @rtype: BaseDRBDCmdGenerator
 131
 132     """
 133     version = info.GetVersion()
 134     if version["k_minor"] <= 3:
 135       return drbd_cmdgen.DRBD83CmdGenerator(version)
 136     else:
 137       return drbd_cmdgen.DRBD84CmdGenerator(version)
 138
 139   @staticmethod
 140   def ShutdownAll(minor):
 141     """Deactivate the device.
 142
 143     This will, of course, fail if the device is in use.
 144
 145     @type minor: int
 146     @param minor: the minor to shut down
 147
 148     """
 149     info = DRBD8.GetProcInfo()
 150     cmd_gen = DRBD8.GetCmdGenerator(info)
 151
 152     cmd = cmd_gen.GenDownCmd(minor)
 153     result = utils.RunCmd(cmd)
 154     if result.failed:
 155       base.ThrowError("drbd%d: can't shutdown drbd device: %s",
 156                       minor, result.output)
 157
 158
 159 class DRBD8Dev(base.BlockDev):
 160   """DRBD v8.x block device.
 161
 162   This implements the local host part of the DRBD device, i.e. it
 163   doesn't do anything to the supposed peer. If you need a fully
 164   connected DRBD pair, you need to use this class on both hosts.
 165
 166   The unique_id for the drbd device is a (local_ip, local_port,
 167   remote_ip, remote_port, local_minor, secret) tuple, and it must have
 168   two children: the data device and the meta_device. The meta device
 169   is checked for valid size and is zeroed on create.
 170
 171   """
 172   _DRBD_MAJOR = 147
 173
 174   # timeout constants
 175   _NET_RECONFIG_TIMEOUT = 60
 176
 177   def __init__(self, unique_id, children, size, params):
 178     if children and children.count(None) > 0:
 179       children = []
 180     if len(children) not in (0, 2):
 181       raise ValueError("Invalid configuration data %s" % str(children))
 182     if not isinstance(unique_id, (tuple, list)) or len(unique_id) != 6:
 183       raise ValueError("Invalid configuration data %s" % str(unique_id))
 184     (self._lhost, self._lport,
 185      self._rhost, self._rport,
 186      self._aminor, self._secret) = unique_id
 187     if children:
 188       if not _CanReadDevice(children[1].dev_path):
 189         logging.info("drbd%s: Ignoring unreadable meta device", self._aminor)
 190         children = []
 191     super(DRBD8Dev, self).__init__(unique_id, children, size, params)
 192     self.major = self._DRBD_MAJOR
 193
 194     info = DRBD8.GetProcInfo()
 195     version = info.GetVersion()
 196     if version["k_major"] != 8:
 197       base.ThrowError("Mismatch in DRBD kernel version and requested ganeti"
 198                       " usage: kernel is %s.%s, ganeti wants 8.x",
 199                       version["k_major"], version["k_minor"])
 200
 201     if version["k_minor"] <= 3:
 202       self._show_info_cls = drbd_info.DRBD83ShowInfo
 203     else:
 204       self._show_info_cls = drbd_info.DRBD84ShowInfo
 205
 206     self._cmd_gen = DRBD8.GetCmdGenerator(info)
 207
 208     if (self._lhost is not None and self._lhost == self._rhost and
 209             self._lport == self._rport):
 210       raise ValueError("Invalid configuration data, same local/remote %s" %
 211                        (unique_id,))
 212     self.Attach()
 213
 214   @staticmethod
 215   def _DevPath(minor):
 216     """Return the path to a drbd device for a given minor.
 217
 218     @type minor: int
 219     @rtype: string
 220
 221     """
 222     return "/dev/drbd%d" % minor
 223
 224   def _SetFromMinor(self, minor):
 225     """Set our parameters based on the given minor.
 226
 227     This sets our minor variable and our dev_path.
 228
 229     @type minor: int
 230
 231     """
 232     if minor is None:
 233       self.minor = self.dev_path = None
 234       self.attached = False
 235     else:
 236       self.minor = minor
 237       self.dev_path = self._DevPath(minor)
 238       self.attached = True
 239
 240   @staticmethod
 241   def _CheckMetaSize(meta_device):
 242     """Check if the given meta device looks like a valid one.
 243
 244     This currently only checks the size, which must be around
 245     128MiB.
 246
 247     @type meta_device: string
 248     @param meta_device: the path to the device to check
 249
 250     """
 251     result = utils.RunCmd(["blockdev", "--getsize", meta_device])
 252     if result.failed:
 253       base.ThrowError("Failed to get device size: %s - %s",
 254                       result.fail_reason, result.output)
 255     try:
 256       sectors = int(result.stdout)
 257     except (TypeError, ValueError):
 258       base.ThrowError("Invalid output from blockdev: '%s'", result.stdout)
 259     num_bytes = sectors * 512
 260     if num_bytes < 128 * 1024 * 1024: # less than 128MiB
 261       base.ThrowError("Meta device too small (%.2fMib)",
 262                       (num_bytes / 1024 / 1024))
 263     # the maximum *valid* size of the meta device when living on top
 264     # of LVM is hard to compute: it depends on the number of stripes
 265     # and the PE size; e.g. a 2-stripe, 64MB PE will result in a 128MB
 266     # (normal size), but an eight-stripe 128MB PE will result in a 1GB
 267     # size meta device; as such, we restrict it to 1GB (a little bit
 268     # too generous, but making assumptions about PE size is hard)
 269     if num_bytes > 1024 * 1024 * 1024:
 270       base.ThrowError("Meta device too big (%.2fMiB)",
 271                       (num_bytes / 1024 / 1024))
 272
 273   def _GetShowData(self, minor):
 274     """Return the `drbdsetup show` data.
 275
 276     @type minor: int
 277     @param minor: the minor to collect show output for
 278     @rtype: string
 279
 280     """
 281     result = utils.RunCmd(self._cmd_gen.GenShowCmd(minor))
 282     if result.failed:
 283       logging.error("Can't display the drbd config: %s - %s",
 284                     result.fail_reason, result.output)
 285       return None
 286     return result.stdout
 287
 288   def _GetShowInfo(self, minor):
 289     """Return parsed information from `drbdsetup show`.
 290
 291     @type minor: int
 292     @param minor: the minor to return information for
 293     @rtype: dict as described in L{drbd_info.BaseShowInfo.GetDevInfo}
 294
 295     """
 296     return self._show_info_cls.GetDevInfo(self._GetShowData(minor))
 297
 298   def _MatchesLocal(self, info):
 299     """Test if our local config matches with an existing device.
 300
 301     The parameter should be as returned from `_GetShowInfo()`. This
 302     method tests if our local backing device is the same as the one in
 303     the info parameter, in effect testing if we look like the given
 304     device.
 305
 306     @type info: dict as described in L{drbd_info.BaseShowInfo.GetDevInfo}
 307     @rtype: boolean
 308
 309     """
 310     if self._children:
 311       backend, meta = self._children
 312     else:
 313       backend = meta = None
 314
 315     if backend is not None:
 316       retval = ("local_dev" in info and info["local_dev"] == backend.dev_path)
 317     else:
 318       retval = ("local_dev" not in info)
 319
 320     if meta is not None:
 321       retval = retval and ("meta_dev" in info and
 322                            info["meta_dev"] == meta.dev_path)
 323       if "meta_index" in info:
 324         retval = retval and info["meta_index"] == 0
 325     else:
 326       retval = retval and ("meta_dev" not in info and
 327                            "meta_index" not in info)
 328     return retval
 329
 330   def _MatchesNet(self, info):
 331     """Test if our network config matches with an existing device.
 332
 333     The parameter should be as returned from `_GetShowInfo()`. This
 334     method tests if our network configuration is the same as the one
 335     in the info parameter, in effect testing if we look like the given
 336     device.
 337
 338     @type info: dict as described in L{drbd_info.BaseShowInfo.GetDevInfo}
 339     @rtype: boolean
 340
 341     """
 342     if (((self._lhost is None and not ("local_addr" in info)) and
 343          (self._rhost is None and not ("remote_addr" in info)))):
 344       return True
 345
 346     if self._lhost is None:
 347       return False
 348
 349     if not ("local_addr" in info and
 350             "remote_addr" in info):
 351       return False
 352
 353     retval = (info["local_addr"] == (self._lhost, self._lport))
 354     retval = (retval and
 355               info["remote_addr"] == (self._rhost, self._rport))
 356     return retval
 357
 358   def _AssembleLocal(self, minor, backend, meta, size):
 359     """Configure the local part of a DRBD device.
 360
 361     @type minor: int
 362     @param minor: the minor to assemble locally
 363     @type backend: string
 364     @param backend: path to the data device to use
 365     @type meta: string
 366     @param meta: path to the meta device to use
 367     @type size: int
 368     @param size: size in MiB
 369
 370     """
 371     cmds = self._cmd_gen.GenLocalInitCmds(minor, backend, meta,
 372                                           size, self.params)
 373
 374     for cmd in cmds:
 375       result = utils.RunCmd(cmd)
 376       if result.failed:
 377         base.ThrowError("drbd%d: can't attach local disk: %s",
 378                         minor, result.output)
 379
 380   def _AssembleNet(self, minor, net_info, dual_pri=False, hmac=None,
 381                    secret=None):
 382     """Configure the network part of the device.
 383
 384     @type minor: int
 385     @param minor: the minor to assemble the network for
 386     @type net_info: (string, int, string, int)
 387     @param net_info: tuple containing the local address, local port, remote
 388       address and remote port
 389     @type dual_pri: boolean
 390     @param dual_pri: whether two primaries should be allowed or not
 391     @type hmac: string
 392     @param hmac: the HMAC algorithm to use
 393     @type secret: string
 394     @param secret: the shared secret to use
 395
 396     """
 397     lhost, lport, rhost, rport = net_info
 398     if None in net_info:
 399       # we don't want network connection and actually want to make
 400       # sure its shutdown
 401       self._ShutdownNet(minor)
 402       return
 403
 404     if dual_pri:
 405       protocol = constants.DRBD_MIGRATION_NET_PROTOCOL
 406     else:
 407       protocol = self.params[constants.LDP_PROTOCOL]
 408
 409     # Workaround for a race condition. When DRBD is doing its dance to
 410     # establish a connection with its peer, it also sends the
 411     # synchronization speed over the wire. In some cases setting the
 412     # sync speed only after setting up both sides can race with DRBD
 413     # connecting, hence we set it here before telling DRBD anything
 414     # about its peer.
 415     sync_errors = self._SetMinorSyncParams(minor, self.params)
 416     if sync_errors:
 417       base.ThrowError("drbd%d: can't set the synchronization parameters: %s" %
 418                       (minor, utils.CommaJoin(sync_errors)))
 419
 420     family = self._GetNetFamily(minor, lhost, rhost)
 421
 422     cmd = self._cmd_gen.GenNetInitCmd(minor, family, lhost, lport,
 423                                       rhost, rport, protocol,
 424                                       dual_pri, hmac, secret, self.params)
 425
 426     result = utils.RunCmd(cmd)
 427     if result.failed:
 428       base.ThrowError("drbd%d: can't setup network: %s - %s",
 429                       minor, result.fail_reason, result.output)
 430
 431     def _CheckNetworkConfig():
 432       info = self._GetShowInfo(minor)
 433       if not "local_addr" in info or not "remote_addr" in info:
 434         raise utils.RetryAgain()
 435
 436       if (info["local_addr"] != (lhost, lport) or
 437           info["remote_addr"] != (rhost, rport)):
 438         raise utils.RetryAgain()
 439
 440     try:
 441       utils.Retry(_CheckNetworkConfig, 1.0, 10.0)
 442     except utils.RetryTimeout:
 443       base.ThrowError("drbd%d: timeout while configuring network", minor)
 444
 445   @staticmethod
 446   def _GetNetFamily(minor, lhost, rhost):
 447     if netutils.IP6Address.IsValid(lhost):
 448       if not netutils.IP6Address.IsValid(rhost):
 449         base.ThrowError("drbd%d: can't connect ip %s to ip %s" %
 450                         (minor, lhost, rhost))
 451       return "ipv6"
 452     elif netutils.IP4Address.IsValid(lhost):
 453       if not netutils.IP4Address.IsValid(rhost):
 454         base.ThrowError("drbd%d: can't connect ip %s to ip %s" %
 455                         (minor, lhost, rhost))
 456       return "ipv4"
 457     else:
 458       base.ThrowError("drbd%d: Invalid ip %s" % (minor, lhost))
 459
 460   def AddChildren(self, devices):
 461     """Add a disk to the DRBD device.
 462
 463     @type devices: list of L{BlockDev}
 464     @param devices: a list of exactly two L{BlockDev} objects; the first
 465       denotes the data device, the second the meta device for this DRBD device
 466
 467     """
 468     if self.minor is None:
 469       base.ThrowError("drbd%d: can't attach to dbrd8 during AddChildren",
 470                       self._aminor)
 471     if len(devices) != 2:
 472       base.ThrowError("drbd%d: need two devices for AddChildren", self.minor)
 473     info = self._GetShowInfo(self.minor)
 474     if "local_dev" in info:
 475       base.ThrowError("drbd%d: already attached to a local disk", self.minor)
 476     backend, meta = devices
 477     if backend.dev_path is None or meta.dev_path is None:
 478       base.ThrowError("drbd%d: children not ready during AddChildren",
 479                       self.minor)
 480     backend.Open()
 481     meta.Open()
 482     self._CheckMetaSize(meta.dev_path)
 483     self._InitMeta(DRBD8.FindUnusedMinor(), meta.dev_path)
 484
 485     self._AssembleLocal(self.minor, backend.dev_path, meta.dev_path, self.size)
 486     self._children = devices
 487
 488   def RemoveChildren(self, devices):
 489     """Detach the drbd device from local storage.
 490
 491     @type devices: list of L{BlockDev}
 492     @param devices: a list of exactly two L{BlockDev} objects; the first
 493       denotes the data device, the second the meta device for this DRBD device
 494
 495     """
 496     if self.minor is None:
 497       base.ThrowError("drbd%d: can't attach to drbd8 during RemoveChildren",
 498                       self._aminor)
 499     # early return if we don't actually have backing storage
 500     info = self._GetShowInfo(self.minor)
 501     if "local_dev" not in info:
 502       return
 503     if len(self._children) != 2:
 504       base.ThrowError("drbd%d: we don't have two children: %s", self.minor,
 505                       self._children)
 506     if self._children.count(None) == 2: # we don't actually have children :)
 507       logging.warning("drbd%d: requested detach while detached", self.minor)
 508       return
 509     if len(devices) != 2:
 510       base.ThrowError("drbd%d: we need two children in RemoveChildren",
 511                       self.minor)
 512     for child, dev in zip(self._children, devices):
 513       if dev != child.dev_path:
 514         base.ThrowError("drbd%d: mismatch in local storage (%s != %s) in"
 515                         " RemoveChildren", self.minor, dev, child.dev_path)
 516
 517     self._ShutdownLocal(self.minor)
 518     self._children = []
 519
 520   def _SetMinorSyncParams(self, minor, params):
 521     """Set the parameters of the DRBD syncer.
 522
 523     This is the low-level implementation.
 524
 525     @type minor: int
 526     @param minor: the drbd minor whose settings we change
 527     @type params: dict
 528     @param params: LD level disk parameters related to the synchronization
 529     @rtype: list
 530     @return: a list of error messages
 531
 532     """
 533     cmd = self._cmd_gen.GenSyncParamsCmd(minor, params)
 534     result = utils.RunCmd(cmd)
 535     if result.failed:
 536       msg = ("Can't change syncer rate: %s - %s" %
 537              (result.fail_reason, result.output))
 538       logging.error(msg)
 539       return [msg]
 540
 541     return []
 542
 543   def SetSyncParams(self, params):
 544     """Set the synchronization parameters of the DRBD syncer.
 545
 546     See L{BlockDev.SetSyncParams} for parameter description.
 547
 548     """
 549     if self.minor is None:
 550       err = "Not attached during SetSyncParams"
 551       logging.info(err)
 552       return [err]
 553
 554     children_result = super(DRBD8Dev, self).SetSyncParams(params)
 555     children_result.extend(self._SetMinorSyncParams(self.minor, params))
 556     return children_result
 557
 558   def PauseResumeSync(self, pause):
 559     """Pauses or resumes the sync of a DRBD device.
 560
 561     See L{BlockDev.PauseResumeSync} for parameter description.
 562
 563     """
 564     if self.minor is None:
 565       logging.info("Not attached during PauseSync")
 566       return False
 567
 568     children_result = super(DRBD8Dev, self).PauseResumeSync(pause)
 569
 570     if pause:
 571       cmd = self._cmd_gen.GenPauseSyncCmd(self.minor)
 572     else:
 573       cmd = self._cmd_gen.GenResumeSyncCmd(self.minor)
 574
 575     result = utils.RunCmd(cmd)
 576     if result.failed:
 577       logging.error("Can't %s: %s - %s", cmd,
 578                     result.fail_reason, result.output)
 579     return not result.failed and children_result
 580
 581   def GetProcStatus(self):
 582     """Return the current status data from /proc/drbd for this device.
 583
 584     @rtype: DRBD8Status
 585
 586     """
 587     if self.minor is None:
 588       base.ThrowError("drbd%d: GetStats() called while not attached",
 589                       self._aminor)
 590     info = DRBD8.GetProcInfo()
 591     if not info.HasMinorStatus(self.minor):
 592       base.ThrowError("drbd%d: can't find myself in /proc", self.minor)
 593     return info.GetMinorStatus(self.minor)
 594
 595   def GetSyncStatus(self):
 596     """Returns the sync status of the device.
 597
 598     If sync_percent is None, it means all is ok
 599     If estimated_time is None, it means we can't estimate
 600     the time needed, otherwise it's the time left in seconds.
 601
 602     We set the is_degraded parameter to True on two conditions:
 603     network not connected or local disk missing.
 604
 605     We compute the ldisk parameter based on whether we have a local
 606     disk or not.
 607
 608     @rtype: objects.BlockDevStatus
 609
 610     """
 611     if self.minor is None and not self.Attach():
 612       base.ThrowError("drbd%d: can't Attach() in GetSyncStatus", self._aminor)
 613
 614     stats = self.GetProcStatus()
 615     is_degraded = not stats.is_connected or not stats.is_disk_uptodate
 616
 617     if stats.is_disk_uptodate:
 618       ldisk_status = constants.LDS_OKAY
 619     elif stats.is_diskless:
 620       ldisk_status = constants.LDS_FAULTY
 621     else:
 622       ldisk_status = constants.LDS_UNKNOWN
 623
 624     return objects.BlockDevStatus(dev_path=self.dev_path,
 625                                   major=self.major,
 626                                   minor=self.minor,
 627                                   sync_percent=stats.sync_percent,
 628                                   estimated_time=stats.est_time,
 629                                   is_degraded=is_degraded,
 630                                   ldisk_status=ldisk_status)
 631
 632   def Open(self, force=False):
 633     """Make the local state primary.
 634
 635     If the 'force' parameter is given, DRBD is instructed to switch the device
 636     into primary mode. Since this is a potentially dangerous operation, the
 637     force flag should be only given after creation, when it actually is
 638     mandatory.
 639
 640     """
 641     if self.minor is None and not self.Attach():
 642       logging.error("DRBD cannot attach to a device during open")
 643       return False
 644
 645     cmd = self._cmd_gen.GenPrimaryCmd(self.minor, force)
 646
 647     result = utils.RunCmd(cmd)
 648     if result.failed:
 649       base.ThrowError("drbd%d: can't make drbd device primary: %s", self.minor,
 650                       result.output)
 651
 652   def Close(self):
 653     """Make the local state secondary.
 654
 655     This will, of course, fail if the device is in use.
 656
 657     """
 658     if self.minor is None and not self.Attach():
 659       base.ThrowError("drbd%d: can't Attach() in Close()", self._aminor)
 660     cmd = self._cmd_gen.GenSecondaryCmd(self.minor)
 661     result = utils.RunCmd(cmd)
 662     if result.failed:
 663       base.ThrowError("drbd%d: can't switch drbd device to secondary: %s",
 664                       self.minor, result.output)
 665
 666   def DisconnectNet(self):
 667     """Removes network configuration.
 668
 669     This method shutdowns the network side of the device.
 670
 671     The method will wait up to a hardcoded timeout for the device to
 672     go into standalone after the 'disconnect' command before
 673     re-configuring it, as sometimes it takes a while for the
 674     disconnect to actually propagate and thus we might issue a 'net'
 675     command while the device is still connected. If the device will
 676     still be attached to the network and we time out, we raise an
 677     exception.
 678
 679     """
 680     if self.minor is None:
 681       base.ThrowError("drbd%d: disk not attached in re-attach net",
 682                       self._aminor)
 683
 684     if None in (self._lhost, self._lport, self._rhost, self._rport):
 685       base.ThrowError("drbd%d: DRBD disk missing network info in"
 686                       " DisconnectNet()", self.minor)
 687
 688     class _DisconnectStatus:
 689       def __init__(self, ever_disconnected):
 690         self.ever_disconnected = ever_disconnected
 691
 692     dstatus = _DisconnectStatus(base.IgnoreError(self._ShutdownNet, self.minor))
 693
 694     def _WaitForDisconnect():
 695       if self.GetProcStatus().is_standalone:
 696         return
 697
 698       # retry the disconnect, it seems possible that due to a well-time
 699       # disconnect on the peer, my disconnect command might be ignored and
 700       # forgotten
 701       dstatus.ever_disconnected = \
 702         base.IgnoreError(self._ShutdownNet, self.minor) or \
 703         dstatus.ever_disconnected
 704
 705       raise utils.RetryAgain()
 706
 707     # Keep start time
 708     start_time = time.time()
 709
 710     try:
 711       # Start delay at 100 milliseconds and grow up to 2 seconds
 712       utils.Retry(_WaitForDisconnect, (0.1, 1.5, 2.0),
 713                   self._NET_RECONFIG_TIMEOUT)
 714     except utils.RetryTimeout:
 715       if dstatus.ever_disconnected:
 716         msg = ("drbd%d: device did not react to the"
 717                " 'disconnect' command in a timely manner")
 718       else:
 719         msg = "drbd%d: can't shutdown network, even after multiple retries"
 720
 721       base.ThrowError(msg, self.minor)
 722
 723     reconfig_time = time.time() - start_time
 724     if reconfig_time > (self._NET_RECONFIG_TIMEOUT * 0.25):
 725       logging.info("drbd%d: DisconnectNet: detach took %.3f seconds",
 726                    self.minor, reconfig_time)
 727
 728   def AttachNet(self, multimaster):
 729     """Reconnects the network.
 730
 731     This method connects the network side of the device with a
 732     specified multi-master flag. The device needs to be 'Standalone'
 733     but have valid network configuration data.
 734
 735     @type multimaster: boolean
 736     @param multimaster: init the network in dual-primary mode
 737
 738     """
 739     if self.minor is None:
 740       base.ThrowError("drbd%d: device not attached in AttachNet", self._aminor)
 741
 742     if None in (self._lhost, self._lport, self._rhost, self._rport):
 743       base.ThrowError("drbd%d: missing network info in AttachNet()", self.minor)
 744
 745     status = self.GetProcStatus()
 746
 747     if not status.is_standalone:
 748       base.ThrowError("drbd%d: device is not standalone in AttachNet",
 749                       self.minor)
 750
 751     self._AssembleNet(self.minor,
 752                       (self._lhost, self._lport, self._rhost, self._rport),
 753                       dual_pri=multimaster, hmac=constants.DRBD_HMAC_ALG,
 754                       secret=self._secret)
 755
 756   def Attach(self):
 757     """Check if our minor is configured.
 758
 759     This doesn't do any device configurations - it only checks if the
 760     minor is in a state different from Unconfigured.
 761
 762     Note that this function will not change the state of the system in
 763     any way (except in case of side-effects caused by reading from
 764     /proc).
 765
 766     """
 767     used_devs = DRBD8.GetUsedDevs()
 768     if self._aminor in used_devs:
 769       minor = self._aminor
 770     else:
 771       minor = None
 772
 773     self._SetFromMinor(minor)
 774     return minor is not None
 775
 776   def Assemble(self):
 777     """Assemble the drbd.
 778
 779     Method:
 780       - if we have a configured device, we try to ensure that it matches
 781         our config
 782       - if not, we create it from zero
 783       - anyway, set the device parameters
 784
 785     """
 786     super(DRBD8Dev, self).Assemble()
 787
 788     self.Attach()
 789     if self.minor is None:
 790       # local device completely unconfigured
 791       self._FastAssemble()
 792     else:
 793       # we have to recheck the local and network status and try to fix
 794       # the device
 795       self._SlowAssemble()
 796
 797     sync_errors = self.SetSyncParams(self.params)
 798     if sync_errors:
 799       base.ThrowError("drbd%d: can't set the synchronization parameters: %s" %
 800                       (self.minor, utils.CommaJoin(sync_errors)))
 801
 802   def _SlowAssemble(self):
 803     """Assembles the DRBD device from a (partially) configured device.
 804
 805     In case of partially attached (local device matches but no network
 806     setup), we perform the network attach. If successful, we re-test
 807     the attach if can return success.
 808
 809     """
 810     # TODO: Rewrite to not use a for loop just because there is 'break'
 811     # pylint: disable=W0631
 812     net_data = (self._lhost, self._lport, self._rhost, self._rport)
 813     for minor in (self._aminor,):
 814       info = self._GetShowInfo(minor)
 815       match_l = self._MatchesLocal(info)
 816       match_r = self._MatchesNet(info)
 817
 818       if match_l and match_r:
 819         # everything matches
 820         break
 821
 822       if match_l and not match_r and "local_addr" not in info:
 823         # disk matches, but not attached to network, attach and recheck
 824         self._AssembleNet(minor, net_data, hmac=constants.DRBD_HMAC_ALG,
 825                           secret=self._secret)
 826         if self._MatchesNet(self._GetShowInfo(minor)):
 827           break
 828         else:
 829           base.ThrowError("drbd%d: network attach successful, but 'drbdsetup"
 830                           " show' disagrees", minor)
 831
 832       if match_r and "local_dev" not in info:
 833         # no local disk, but network attached and it matches
 834         self._AssembleLocal(minor, self._children[0].dev_path,
 835                             self._children[1].dev_path, self.size)
 836         if self._MatchesLocal(self._GetShowInfo(minor)):
 837           break
 838         else:
 839           base.ThrowError("drbd%d: disk attach successful, but 'drbdsetup"
 840                           " show' disagrees", minor)
 841
 842       # this case must be considered only if we actually have local
 843       # storage, i.e. not in diskless mode, because all diskless
 844       # devices are equal from the point of view of local
 845       # configuration
 846       if (match_l and "local_dev" in info and
 847           not match_r and "local_addr" in info):
 848         # strange case - the device network part points to somewhere
 849         # else, even though its local storage is ours; as we own the
 850         # drbd space, we try to disconnect from the remote peer and
 851         # reconnect to our correct one
 852         try:
 853           self._ShutdownNet(minor)
 854         except errors.BlockDeviceError, err:
 855           base.ThrowError("drbd%d: device has correct local storage, wrong"
 856                           " remote peer and is unable to disconnect in order"
 857                           " to attach to the correct peer: %s", minor, str(err))
 858         # note: _AssembleNet also handles the case when we don't want
 859         # local storage (i.e. one or more of the _[lr](host|port) is
 860         # None)
 861         self._AssembleNet(minor, net_data, hmac=constants.DRBD_HMAC_ALG,
 862                           secret=self._secret)
 863         if self._MatchesNet(self._GetShowInfo(minor)):
 864           break
 865         else:
 866           base.ThrowError("drbd%d: network attach successful, but 'drbdsetup"
 867                           " show' disagrees", minor)
 868
 869     else:
 870       minor = None
 871
 872     self._SetFromMinor(minor)
 873     if minor is None:
 874       base.ThrowError("drbd%d: cannot activate, unknown or unhandled reason",
 875                       self._aminor)
 876
 877   def _FastAssemble(self):
 878     """Assemble the drbd device from zero.
 879
 880     This is run when in Assemble we detect our minor is unused.
 881
 882     """
 883     minor = self._aminor
 884     if self._children and self._children[0] and self._children[1]:
 885       self._AssembleLocal(minor, self._children[0].dev_path,
 886                           self._children[1].dev_path, self.size)
 887     if self._lhost and self._lport and self._rhost and self._rport:
 888       self._AssembleNet(minor,
 889                         (self._lhost, self._lport, self._rhost, self._rport),
 890                         hmac=constants.DRBD_HMAC_ALG, secret=self._secret)
 891     self._SetFromMinor(minor)
 892
 893   def _ShutdownLocal(self, minor):
 894     """Detach from the local device.
 895
 896     I/Os will continue to be served from the remote device. If we
 897     don't have a remote device, this operation will fail.
 898
 899     @type minor: int
 900     @param minor: the device to detach from the local device
 901
 902     """
 903     cmd = self._cmd_gen.GenDetachCmd(minor)
 904     result = utils.RunCmd(cmd)
 905     if result.failed:
 906       base.ThrowError("drbd%d: can't detach local disk: %s",
 907                       minor, result.output)
 908
 909   def _ShutdownNet(self, minor):
 910     """Disconnect from the remote peer.
 911
 912     This fails if we don't have a local device.
 913
 914     @type minor: boolean
 915     @param minor: the device to disconnect from the remote peer
 916
 917     """
 918     family = self._GetNetFamily(minor, self._lhost, self._rhost)
 919     cmd = self._cmd_gen.GenDisconnectCmd(minor, family,
 920                                          self._lhost, self._lport,
 921                                          self._rhost, self._rport)
 922     result = utils.RunCmd(cmd)
 923     if result.failed:
 924       base.ThrowError("drbd%d: can't shutdown network: %s",
 925                       minor, result.output)
 926
 927   def Shutdown(self):
 928     """Shutdown the DRBD device.
 929
 930     """
 931     if self.minor is None and not self.Attach():
 932       logging.info("drbd%d: not attached during Shutdown()", self._aminor)
 933       return
 934
 935     try:
 936       DRBD8.ShutdownAll(self.minor)
 937     finally:
 938       self.minor = None
 939       self.dev_path = None
 940
 941   def Remove(self):
 942     """Stub remove for DRBD devices.
 943
 944     """
 945     self.Shutdown()
 946
 947   def Rename(self, new_id):
 948     """Rename a device.
 949
 950     This is not supported for drbd devices.
 951
 952     """
 953     raise errors.ProgrammerError("Can't rename a drbd device")
 954
 955   def Grow(self, amount, dryrun, backingstore, excl_stor):
 956     """Resize the DRBD device and its backing storage.
 957
 958     See L{BlockDev.Grow} for parameter description.
 959
 960     """
 961     if self.minor is None:
 962       base.ThrowError("drbd%d: Grow called while not attached", self._aminor)
 963     if len(self._children) != 2 or None in self._children:
 964       base.ThrowError("drbd%d: cannot grow diskless device", self.minor)
 965     self._children[0].Grow(amount, dryrun, backingstore, excl_stor)
 966     if dryrun or backingstore:
 967       # DRBD does not support dry-run mode and is not backing storage,
 968       # so we'll return here
 969       return
 970     cmd = self._cmd_gen.GenResizeCmd(self.minor, self.size + amount)
 971     result = utils.RunCmd(cmd)
 972     if result.failed:
 973       base.ThrowError("drbd%d: resize failed: %s", self.minor, result.output)
 974
 975   @classmethod
 976   def _InitMeta(cls, minor, dev_path):
 977     """Initialize a meta device.
 978
 979     This will not work if the given minor is in use.
 980
 981     @type minor: int
 982     @param minor: the DRBD minor whose (future) meta device should be
 983       initialized
 984     @type dev_path: string
 985     @param dev_path: path to the meta device to initialize
 986
 987     """
 988     # Zero the metadata first, in order to make sure drbdmeta doesn't
 989     # try to auto-detect existing filesystems or similar (see
 990     # http://code.google.com/p/ganeti/issues/detail?id=182); we only
 991     # care about the first 128MB of data in the device, even though it
 992     # can be bigger
 993     result = utils.RunCmd([constants.DD_CMD,
 994                            "if=/dev/zero", "of=%s" % dev_path,
 995                            "bs=1048576", "count=128", "oflag=direct"])
 996     if result.failed:
 997       base.ThrowError("Can't wipe the meta device: %s", result.output)
 998
 999     info = DRBD8.GetProcInfo()
1000     cmd_gen = DRBD8.GetCmdGenerator(info)
1001     cmd = cmd_gen.GenInitMetaCmd(minor, dev_path)
1002
1003     result = utils.RunCmd(cmd)
1004     if result.failed:
1005       base.ThrowError("Can't initialize meta device: %s", result.output)
1006
1007   @classmethod
1008   def Create(cls, unique_id, children, size, spindles, params, excl_stor):
1009     """Create a new DRBD8 device.
1010
1011     Since DRBD devices are not created per se, just assembled, this
1012     function only initializes the metadata.
1013
1014     """
1015     if len(children) != 2:
1016       raise errors.ProgrammerError("Invalid setup for the drbd device")
1017     if excl_stor:
1018       raise errors.ProgrammerError("DRBD device requested with"
1019                                    " exclusive_storage")
1020     # check that the minor is unused
1021     aminor = unique_id[4]
1022
1023     info = DRBD8.GetProcInfo()
1024     if info.HasMinorStatus(aminor):
1025       status = info.GetMinorStatus(aminor)
1026       in_use = status.is_in_use
1027     else:
1028       in_use = False
1029     if in_use:
1030       base.ThrowError("drbd%d: minor is already in use at Create() time",
1031                       aminor)
1032     meta = children[1]
1033     meta.Assemble()
1034     if not meta.Attach():
1035       base.ThrowError("drbd%d: can't attach to meta device '%s'",
1036                       aminor, meta)
1037     cls._CheckMetaSize(meta.dev_path)
1038     cls._InitMeta(aminor, meta.dev_path)
1039     return cls(unique_id, children, size, params)
1040
1041
1042 def _CanReadDevice(path):
1043   """Check if we can read from the given device.
1044
1045   This tries to read the first 128k of the device.
1046
1047   @type path: string
1048
1049   """
1050   try:
1051     utils.ReadFile(path, size=_DEVICE_READ_SIZE)
1052     return True
1053   except EnvironmentError:
1054     logging.warning("Can't read from device %s", path, exc_info=True)
1055     return False