Implement disk verify checks in config verify

[ganeti-local] / lib / bdev.py

diff --git a/lib/bdev.py b/lib/bdev.py
index dd35e36..834d7b3 100644 (file)
--- a/lib/bdev.py
+++ b/lib/bdev.py
@@ -26,9 +26,9 @@ import time
 import errno
 import pyparsing as pyp
 import os
 import errno
 import pyparsing as pyp
 import os

+import logging

 
 from ganeti import utils
 
 from ganeti import utils

-from ganeti import logger

 from ganeti import errors
 from ganeti import constants
 
 from ganeti import errors
 from ganeti import constants
 

@@ -82,40 +82,21 @@ class BlockDev(object):
     self.unique_id = unique_id
     self.major = None
     self.minor = None
     self.unique_id = unique_id
     self.major = None
     self.minor = None

+    self.attached = False

 
   def Assemble(self):
     """Assemble the device from its components.
 
 
   def Assemble(self):
     """Assemble the device from its components.
 

-    If this is a plain block device (e.g. LVM) than assemble does
-    nothing, as the LVM has no children and we don't put logical
-    volumes offline.
-
-    One guarantee is that after the device has been assembled, it
-    knows its major/minor numbers. This allows other devices (usually
-    parents) to probe correctly for their children.
+    Implementations of this method by child classes must ensure that:
+      - after the device has been assembled, it knows its major/minor
+        numbers; this allows other devices (usually parents) to probe
+        correctly for their children
+      - calling this method on an existing, in-use device is safe
+      - if the device is already configured (and in an OK state),
+        this method is idempotent

 
     """
 
     """

-    status = True
-    for child in self._children:
-      if not isinstance(child, BlockDev):
-        raise TypeError("Invalid child passed of type '%s'" % type(child))
-      if not status:
-        break
-      status = status and child.Assemble()
-      if not status:
-        break
-
-      try:
-        child.Open()
-      except errors.BlockDeviceError:
-        for child in self._children:
-          child.Shutdown()
-        raise
-
-    if not status:
-      for child in self._children:
-        child.Shutdown()
-    return status
+    return True

 
   def Attach(self):
     """Find a device which matches our config and attach to it.
 
   def Attach(self):
     """Find a device which matches our config and attach to it.

@@ -201,9 +182,6 @@ class BlockDev(object):
     If this device is a mirroring device, this function returns the
     status of the mirror.
 
     If this device is a mirroring device, this function returns the
     status of the mirror.
 

-    Returns:
-     (sync_percent, estimated_time, is_degraded, ldisk)
-

     If sync_percent is None, it means the device is not syncing.
 
     If estimated_time is None, it means we can't estimate
     If sync_percent is None, it means the device is not syncing.
 
     If estimated_time is None, it means we can't estimate

@@ -217,6 +195,9 @@ class BlockDev(object):
     data. This is only valid for some devices, the rest will always
     return False (not degraded).
 
     data. This is only valid for some devices, the rest will always
     return False (not degraded).
 

+    @rtype: tuple
+    @return: (sync_percent, estimated_time, is_degraded, ldisk)
+

     """
     return None, None, False, False
 
     """
     return None, None, False, False
 

@@ -258,10 +239,7 @@ class BlockDev(object):
   def Grow(self, amount):
     """Grow the block device.
 
   def Grow(self, amount):
     """Grow the block device.
 

-    Arguments:
-      amount: the amount (in mebibytes) to grow with
-
-    Returns: None
+    @param amount: the amount (in mebibytes) to grow with

 
     """
     raise NotImplementedError
 
     """
     raise NotImplementedError

@@ -287,6 +265,8 @@ class LogicalVolume(BlockDev):
       raise ValueError("Invalid configuration data %s" % str(unique_id))
     self._vg_name, self._lv_name = unique_id
     self.dev_path = "/dev/%s/%s" % (self._vg_name, self._lv_name)
       raise ValueError("Invalid configuration data %s" % str(unique_id))
     self._vg_name, self._lv_name = unique_id
     self.dev_path = "/dev/%s/%s" % (self._vg_name, self._lv_name)

+    self._degraded = True
+    self.major = self.minor = None

     self.Attach()
 
   @classmethod
     self.Attach()
 
   @classmethod

@@ -295,7 +275,8 @@ class LogicalVolume(BlockDev):
 
     """
     if not isinstance(unique_id, (tuple, list)) or len(unique_id) != 2:
 
     """
     if not isinstance(unique_id, (tuple, list)) or len(unique_id) != 2:

-      raise ValueError("Invalid configuration data %s" % str(unique_id))
+      raise errors.ProgrammerError("Invalid configuration data %s" %
+                                   str(unique_id))

     vg_name, lv_name = unique_id
     pvs_info = cls.GetPVInfo(vg_name)
     if not pvs_info:
     vg_name, lv_name = unique_id
     pvs_info = cls.GetPVInfo(vg_name)
     if not pvs_info:

@@ -315,19 +296,18 @@ class LogicalVolume(BlockDev):
     result = utils.RunCmd(["lvcreate", "-L%dm" % size, "-n%s" % lv_name,
                            vg_name] + pvlist)
     if result.failed:
     result = utils.RunCmd(["lvcreate", "-L%dm" % size, "-n%s" % lv_name,
                            vg_name] + pvlist)
     if result.failed:

-      raise errors.BlockDeviceError("%s - %s" % (result.fail_reason,
-                                                result.output))
+      raise errors.BlockDeviceError("LV create failed (%s): %s" %
+                                    (result.fail_reason, result.output))

     return LogicalVolume(unique_id, children)
 
   @staticmethod
   def GetPVInfo(vg_name):
     """Get the free space info for PVs in a volume group.
 
     return LogicalVolume(unique_id, children)
 
   @staticmethod
   def GetPVInfo(vg_name):
     """Get the free space info for PVs in a volume group.
 

-    Args:
-      vg_name: the volume group name
+    @param vg_name: the volume group name

 
 

-    Returns:
-      list of (free_space, name) with free_space in mebibytes
+    @rtype: list
+    @return: list of tuples (free_space, name) with free_space in mebibytes

 
     """
     command = ["pvs", "--noheadings", "--nosuffix", "--units=m",
 
     """
     command = ["pvs", "--noheadings", "--nosuffix", "--units=m",

@@ -335,14 +315,14 @@ class LogicalVolume(BlockDev):
                "--separator=:"]
     result = utils.RunCmd(command)
     if result.failed:
                "--separator=:"]
     result = utils.RunCmd(command)
     if result.failed:

-      logger.Error("Can't get the PV information: %s - %s" %
-                   (result.fail_reason, result.output))
+      logging.error("Can't get the PV information: %s - %s",
+                    result.fail_reason, result.output)

       return None
     data = []
     for line in result.stdout.splitlines():
       fields = line.strip().split(':')
       if len(fields) != 4:
       return None
     data = []
     for line in result.stdout.splitlines():
       fields = line.strip().split(':')
       if len(fields) != 4:

-        logger.Error("Can't parse pvs output: line '%s'" % line)
+        logging.error("Can't parse pvs output: line '%s'", line)

         return None
       # skip over pvs from another vg or ones which are not allocatable
       if fields[1] != vg_name or fields[3][0] != 'a':
         return None
       # skip over pvs from another vg or ones which are not allocatable
       if fields[1] != vg_name or fields[3][0] != 'a':

@@ -361,8 +341,8 @@ class LogicalVolume(BlockDev):
     result = utils.RunCmd(["lvremove", "-f", "%s/%s" %
                            (self._vg_name, self._lv_name)])
     if result.failed:
     result = utils.RunCmd(["lvremove", "-f", "%s/%s" %
                            (self._vg_name, self._lv_name)])
     if result.failed:

-      logger.Error("Can't lvremove: %s - %s" %
-                   (result.fail_reason, result.output))
+      logging.error("Can't lvremove: %s - %s",
+                    result.fail_reason, result.output)

 
     return not result.failed
 
 
     return not result.failed
 

@@ -392,19 +372,37 @@ class LogicalVolume(BlockDev):
     recorded.
 
     """
     recorded.
 
     """

-    result = utils.RunCmd(["lvdisplay", self.dev_path])
+    self.attached = False
+    result = utils.RunCmd(["lvs", "--noheadings", "--separator=,",
+                           "-olv_attr,lv_kernel_major,lv_kernel_minor",
+                           self.dev_path])

     if result.failed:
     if result.failed:

-      logger.Error("Can't find LV %s: %s, %s" %
-                   (self.dev_path, result.fail_reason, result.output))
+      logging.error("Can't find LV %s: %s, %s",
+                    self.dev_path, result.fail_reason, result.output)

       return False
       return False

-    match = re.compile("^ *Block device *([0-9]+):([0-9]+).*$")
-    for line in result.stdout.splitlines():
-      match_result = match.match(line)
-      if match_result:
-        self.major = int(match_result.group(1))
-        self.minor = int(match_result.group(2))
-        return True
-    return False
+    out = result.stdout.strip().rstrip(',')
+    out = out.split(",")
+    if len(out) != 3:
+      logging.error("Can't parse LVS output, len(%s) != 3", str(out))
+      return False
+
+    status, major, minor = out[:3]
+    if len(status) != 6:
+      logging.error("lvs lv_attr is not 6 characters (%s)", status)
+      return False
+
+    try:
+      major = int(major)
+      minor = int(minor)
+    except ValueError, err:
+      logging.error("lvs major/minor cannot be parsed: %s", str(err))
+
+    self.major = major
+    self.minor = minor
+    self._degraded = status[0] == 'v' # virtual volume, i.e. doesn't backing
+                                      # storage
+    self.attached = True
+    return True

 
   def Assemble(self):
     """Assemble the device.
 
   def Assemble(self):
     """Assemble the device.

@@ -416,8 +414,9 @@ class LogicalVolume(BlockDev):
     """
     result = utils.RunCmd(["lvchange", "-ay", self.dev_path])
     if result.failed:
     """
     result = utils.RunCmd(["lvchange", "-ay", self.dev_path])
     if result.failed:

-      logger.Error("Can't activate lv %s: %s" % (self.dev_path, result.output))
-    return not result.failed
+      logging.error("Can't activate lv %s: %s", self.dev_path, result.output)
+      return False
+    return self.Attach()

 
   def Shutdown(self):
     """Shutdown the device.
 
   def Shutdown(self):
     """Shutdown the device.

@@ -434,9 +433,6 @@ class LogicalVolume(BlockDev):
     If this device is a mirroring device, this function returns the
     status of the mirror.
 
     If this device is a mirroring device, this function returns the
     status of the mirror.
 

-    Returns:
-     (sync_percent, estimated_time, is_degraded, ldisk)
-

     For logical volumes, sync_percent and estimated_time are always
     None (no recovery in progress, as we don't handle the mirrored LV
     case). The is_degraded parameter is the inverse of the ldisk
     For logical volumes, sync_percent and estimated_time are always
     None (no recovery in progress, as we don't handle the mirrored LV
     case). The is_degraded parameter is the inverse of the ldisk

@@ -448,20 +444,13 @@ class LogicalVolume(BlockDev):
     physical disk failure and subsequent 'vgreduce --removemissing' on
     the volume group.
 
     physical disk failure and subsequent 'vgreduce --removemissing' on
     the volume group.
 

+    The status was already read in Attach, so we just return it.
+
+    @rtype: tuple
+    @return: (sync_percent, estimated_time, is_degraded, ldisk)
+

     """
     """

-    result = utils.RunCmd(["lvs", "--noheadings", "-olv_attr", self.dev_path])
-    if result.failed:
-      logger.Error("Can't display lv: %s - %s" %
-                   (result.fail_reason, result.output))
-      return None, None, True, True
-    out = result.stdout.strip()
-    # format: type/permissions/alloc/fixed_minor/state/open
-    if len(out) != 6:
-      logger.Debug("Error in lvs output: attrs=%s, len != 6" % out)
-      return None, None, True, True
-    ldisk = out[0] == 'v' # virtual volume, i.e. doesn't have
-                          # backing storage
-    return None, None, ldisk, ldisk
+    return None, None, self._degraded, self._degraded

 
   def Open(self, force=False):
     """Make the device ready for I/O.
 
   def Open(self, force=False):
     """Make the device ready for I/O.

@@ -551,20 +540,28 @@ class DRBD8Status(object):
   Note that this doesn't support unconfigured devices (cs:Unconfigured).
 
   """
   Note that this doesn't support unconfigured devices (cs:Unconfigured).
 
   """

+  UNCONF_RE = re.compile(r"\s*[0-9]+:\s*cs:Unconfigured$")

   LINE_RE = re.compile(r"\s*[0-9]+:\s*cs:(\S+)\s+st:([^/]+)/(\S+)"
                        "\s+ds:([^/]+)/(\S+)\s+.*$")
   SYNC_RE = re.compile(r"^.*\ssync'ed:\s*([0-9.]+)%.*"
                        "\sfinish: ([0-9]+):([0-9]+):([0-9]+)\s.*$")
 
   def __init__(self, procline):
   LINE_RE = re.compile(r"\s*[0-9]+:\s*cs:(\S+)\s+st:([^/]+)/(\S+)"
                        "\s+ds:([^/]+)/(\S+)\s+.*$")
   SYNC_RE = re.compile(r"^.*\ssync'ed:\s*([0-9.]+)%.*"
                        "\sfinish: ([0-9]+):([0-9]+):([0-9]+)\s.*$")
 
   def __init__(self, procline):

-    m = self.LINE_RE.match(procline)
-    if not m:
-      raise errors.BlockDeviceError("Can't parse input data '%s'" % procline)
-    self.cstatus = m.group(1)
-    self.lrole = m.group(2)
-    self.rrole = m.group(3)
-    self.ldisk = m.group(4)
-    self.rdisk = m.group(5)
+    u = self.UNCONF_RE.match(procline)
+    if u:
+      self.cstatus = "Unconfigured"
+      self.lrole = self.rrole = self.ldisk = self.rdisk = None
+    else:
+      m = self.LINE_RE.match(procline)
+      if not m:
+        raise errors.BlockDeviceError("Can't parse input data '%s'" % procline)
+      self.cstatus = m.group(1)
+      self.lrole = m.group(2)
+      self.rrole = m.group(3)
+      self.ldisk = m.group(4)
+      self.rdisk = m.group(5)
+
+    # end reading of data from the LINE_RE or UNCONF_RE

 
     self.is_standalone = self.cstatus == "StandAlone"
     self.is_wfconn = self.cstatus == "WFConnection"
 
     self.is_standalone = self.cstatus == "StandAlone"
     self.is_wfconn = self.cstatus == "WFConnection"

@@ -579,6 +576,9 @@ class DRBD8Status(object):
     self.is_diskless = self.ldisk == "Diskless"
     self.is_disk_uptodate = self.ldisk == "UpToDate"
 
     self.is_diskless = self.ldisk == "Diskless"
     self.is_disk_uptodate = self.ldisk == "UpToDate"
 

+    self.is_in_resync = self.cstatus in ("SyncSource", "SyncTarget")
+    self.is_in_use = self.cstatus != "Unconfigured"
+

     m = self.SYNC_RE.match(procline)
     if m:
       self.sync_percent = float(m.group(1))
     m = self.SYNC_RE.match(procline)
     if m:
       self.sync_percent = float(m.group(1))

@@ -630,8 +630,8 @@ class BaseDRBD(BlockDev):
   def _MassageProcData(data):
     """Transform the output of _GetProdData into a nicer form.
 
   def _MassageProcData(data):
     """Transform the output of _GetProdData into a nicer form.
 

-    Returns:
-      a dictionary of minor: joined lines from /proc/drbd for that minor
+    @return: a dictionary of minor: joined lines from /proc/drbd
+        for that minor

 
     """
     lmatch = re.compile("^ *([0-9]+):.*$")
 
     """
     lmatch = re.compile("^ *([0-9]+):.*$")

@@ -657,12 +657,12 @@ class BaseDRBD(BlockDev):
     """Return the DRBD version.
 
     This will return a dict with keys:
     """Return the DRBD version.
 
     This will return a dict with keys:

-      k_major,
-      k_minor,
-      k_point,
-      api,
-      proto,
-      proto2 (only on drbd > 8.2.X)
+      - k_major
+      - k_minor
+      - k_point
+      - api
+      - proto
+      - proto2 (only on drbd > 8.2.X)

 
     """
     proc_data = cls._GetProcData()
 
     """
     proc_data = cls._GetProcData()

@@ -692,7 +692,7 @@ class BaseDRBD(BlockDev):
     return "/dev/drbd%d" % minor
 
   @classmethod
     return "/dev/drbd%d" % minor
 
   @classmethod

-  def _GetUsedDevs(cls):
+  def GetUsedDevs(cls):

     """Compute the list of used DRBD devices.
 
     """
     """Compute the list of used DRBD devices.
 
     """

@@ -720,9 +720,11 @@ class BaseDRBD(BlockDev):
     """
     if minor is None:
       self.minor = self.dev_path = None
     """
     if minor is None:
       self.minor = self.dev_path = None

+      self.attached = False

     else:
       self.minor = minor
       self.dev_path = self._DevPath(minor)
     else:
       self.minor = minor
       self.dev_path = self._DevPath(minor)

+      self.attached = True

 
   @staticmethod
   def _CheckMetaSize(meta_device):
 
   @staticmethod
   def _CheckMetaSize(meta_device):

@@ -734,20 +736,20 @@ class BaseDRBD(BlockDev):
     """
     result = utils.RunCmd(["blockdev", "--getsize", meta_device])
     if result.failed:
     """
     result = utils.RunCmd(["blockdev", "--getsize", meta_device])
     if result.failed:

-      logger.Error("Failed to get device size: %s - %s" %
-                   (result.fail_reason, result.output))
+      logging.error("Failed to get device size: %s - %s",
+                    result.fail_reason, result.output)

       return False
     try:
       sectors = int(result.stdout)
     except ValueError:
       return False
     try:
       sectors = int(result.stdout)
     except ValueError:

-      logger.Error("Invalid output from blockdev: '%s'" % result.stdout)
+      logging.error("Invalid output from blockdev: '%s'", result.stdout)

       return False
     bytes = sectors * 512
     if bytes < 128 * 1024 * 1024: # less than 128MiB
       return False
     bytes = sectors * 512
     if bytes < 128 * 1024 * 1024: # less than 128MiB

-      logger.Error("Meta device too small (%.2fMib)" % (bytes / 1024 / 1024))
+      logging.error("Meta device too small (%.2fMib)", (bytes / 1024 / 1024))

       return False
     if bytes > (128 + 32) * 1024 * 1024: # account for an extra (big) PE on LVM
       return False
     if bytes > (128 + 32) * 1024 * 1024: # account for an extra (big) PE on LVM

-      logger.Error("Meta device too big (%.2fMiB)" % (bytes / 1024 / 1024))
+      logging.error("Meta device too big (%.2fMiB)", (bytes / 1024 / 1024))

       return False
     return True
 
       return False
     return True
 

@@ -776,6 +778,9 @@ class DRBD8(BaseDRBD):
   _MAX_MINORS = 255
   _PARSE_SHOW = None
 
   _MAX_MINORS = 255
   _PARSE_SHOW = None
 

+  # timeout constants
+  _NET_RECONFIG_TIMEOUT = 60
+

   def __init__(self, unique_id, children):
     if children and children.count(None) > 0:
       children = []
   def __init__(self, unique_id, children):
     if children and children.count(None) > 0:
       children = []

@@ -790,9 +795,15 @@ class DRBD8(BaseDRBD):
 
     if len(children) not in (0, 2):
       raise ValueError("Invalid configuration data %s" % str(children))
 
     if len(children) not in (0, 2):
       raise ValueError("Invalid configuration data %s" % str(children))

-    if not isinstance(unique_id, (tuple, list)) or len(unique_id) != 4:
+    if not isinstance(unique_id, (tuple, list)) or len(unique_id) != 6:

       raise ValueError("Invalid configuration data %s" % str(unique_id))
       raise ValueError("Invalid configuration data %s" % str(unique_id))

-    self._lhost, self._lport, self._rhost, self._rport = unique_id
+    (self._lhost, self._lport,
+     self._rhost, self._rport,
+     self._aminor, self._secret) = unique_id
+    if (self._lhost is not None and self._lhost == self._rhost and
+        self._lport == self._rport):
+      raise ValueError("Invalid configuration data, same local/remote %s" %
+                       (unique_id,))

     self.Attach()
 
   @classmethod
     self.Attach()
 
   @classmethod

@@ -832,26 +843,11 @@ class DRBD8(BaseDRBD):
     if highest is None: # there are no minors in use at all
       return 0
     if highest >= cls._MAX_MINORS:
     if highest is None: # there are no minors in use at all
       return 0
     if highest >= cls._MAX_MINORS:

-      logger.Error("Error: no free drbd minors!")
+      logging.error("Error: no free drbd minors!")

       raise errors.BlockDeviceError("Can't find a free DRBD minor")
     return highest + 1
 
   @classmethod
       raise errors.BlockDeviceError("Can't find a free DRBD minor")
     return highest + 1
 
   @classmethod

-  def _IsValidMeta(cls, meta_device):
-    """Check if the given meta device looks like a valid one.
-
-    """
-    minor = cls._FindUnusedMinor()
-    minor_path = cls._DevPath(minor)
-    result = utils.RunCmd(["drbdmeta", minor_path,
-                           "v08", meta_device, "0",
-                           "dstate"])
-    if result.failed:
-      logger.Error("Invalid meta device %s: %s" % (meta_device, result.output))
-      return False
-    return True
-
-  @classmethod

   def _GetShowParser(cls):
     """Return a parser for `drbd show` output.
 
   def _GetShowParser(cls):
     """Return a parser for `drbd show` output.
 

@@ -908,8 +904,8 @@ class DRBD8(BaseDRBD):
     """
     result = utils.RunCmd(["drbdsetup", cls._DevPath(minor), "show"])
     if result.failed:
     """
     result = utils.RunCmd(["drbdsetup", cls._DevPath(minor), "show"])
     if result.failed:

-      logger.Error("Can't display the drbd config: %s - %s" %
-                   (result.fail_reason, result.output))
+      logging.error("Can't display the drbd config: %s - %s",
+                    result.fail_reason, result.output)

       return None
     return result.stdout
 
       return None
     return result.stdout
 

@@ -1012,17 +1008,12 @@ class DRBD8(BaseDRBD):
   def _AssembleLocal(cls, minor, backend, meta):
     """Configure the local part of a DRBD device.
 
   def _AssembleLocal(cls, minor, backend, meta):
     """Configure the local part of a DRBD device.
 

-    This is the first thing that must be done on an unconfigured DRBD
-    device. And it must be done only once.
-

     """
     """

-    if not cls._IsValidMeta(meta):
-      return False

     args = ["drbdsetup", cls._DevPath(minor), "disk",
             backend, meta, "0", "-e", "detach", "--create-device"]
     result = utils.RunCmd(args)
     if result.failed:
     args = ["drbdsetup", cls._DevPath(minor), "disk",
             backend, meta, "0", "-e", "detach", "--create-device"]
     result = utils.RunCmd(args)
     if result.failed:

-      logger.Error("Can't attach local disk: %s" % result.output)
+      logging.error("Can't attach local disk: %s", result.output)

     return not result.failed
 
   @classmethod
     return not result.failed
 
   @classmethod

@@ -1037,6 +1028,14 @@ class DRBD8(BaseDRBD):
       # sure its shutdown
       return cls._ShutdownNet(minor)
 
       # sure its shutdown
       return cls._ShutdownNet(minor)
 

+    # Workaround for a race condition. When DRBD is doing its dance to
+    # establish a connection with its peer, it also sends the
+    # synchronization speed over the wire. In some cases setting the
+    # sync speed only after setting up both sides can race with DRBD
+    # connecting, hence we set it here before telling DRBD anything
+    # about its peer.
+    cls._SetMinorSyncSpeed(minor, constants.SYNC_SPEED)
+

     args = ["drbdsetup", cls._DevPath(minor), "net",
             "%s:%s" % (lhost, lport), "%s:%s" % (rhost, rport), protocol,
             "-A", "discard-zero-changes",
     args = ["drbdsetup", cls._DevPath(minor), "net",
             "%s:%s" % (lhost, lport), "%s:%s" % (rhost, rport), protocol,
             "-A", "discard-zero-changes",

@@ -1049,8 +1048,8 @@ class DRBD8(BaseDRBD):
       args.extend(["-a", hmac, "-x", secret])
     result = utils.RunCmd(args)
     if result.failed:
       args.extend(["-a", hmac, "-x", secret])
     result = utils.RunCmd(args)
     if result.failed:

-      logger.Error("Can't setup network for dbrd device: %s - %s" %
-                   (result.fail_reason, result.output))
+      logging.error("Can't setup network for dbrd device: %s - %s",
+                    result.fail_reason, result.output)

       return False
 
     timeout = time.time() + 10
       return False
 
     timeout = time.time() + 10

@@ -1067,7 +1066,7 @@ class DRBD8(BaseDRBD):
       ok = True
       break
     if not ok:
       ok = True
       break
     if not ok:

-      logger.Error("Timeout while configuring network")
+      logging.error("Timeout while configuring network")

       return False
     return True
 
       return False
     return True
 

@@ -1090,8 +1089,6 @@ class DRBD8(BaseDRBD):
     if not self._CheckMetaSize(meta.dev_path):
       raise errors.BlockDeviceError("Invalid meta device size")
     self._InitMeta(self._FindUnusedMinor(), meta.dev_path)
     if not self._CheckMetaSize(meta.dev_path):
       raise errors.BlockDeviceError("Invalid meta device size")
     self._InitMeta(self._FindUnusedMinor(), meta.dev_path)

-    if not self._IsValidMeta(meta.dev_path):
-      raise errors.BlockDeviceError("Cannot initalize meta device")

 
     if not self._AssembleLocal(self.minor, backend.dev_path, meta.dev_path):
       raise errors.BlockDeviceError("Can't attach to local storage")
 
     if not self._AssembleLocal(self.minor, backend.dev_path, meta.dev_path):
       raise errors.BlockDeviceError("Can't attach to local storage")

@@ -1112,7 +1109,7 @@ class DRBD8(BaseDRBD):
       raise errors.BlockDeviceError("We don't have two children: %s" %
                                     self._children)
     if self._children.count(None) == 2: # we don't actually have children :)
       raise errors.BlockDeviceError("We don't have two children: %s" %
                                     self._children)
     if self._children.count(None) == 2: # we don't actually have children :)

-      logger.Error("Requested detach while detached")
+      logging.error("Requested detach while detached")

       return
     if len(devices) != 2:
       raise errors.BlockDeviceError("We need two children in RemoveChildren")
       return
     if len(devices) != 2:
       raise errors.BlockDeviceError("We need two children in RemoveChildren")

@@ -1126,20 +1123,41 @@ class DRBD8(BaseDRBD):
       raise errors.BlockDeviceError("Can't detach from local storage")
     self._children = []
 
       raise errors.BlockDeviceError("Can't detach from local storage")
     self._children = []
 

+  @classmethod
+  def _SetMinorSyncSpeed(cls, minor, kbytes):
+    """Set the speed of the DRBD syncer.
+
+    This is the low-level implementation.
+
+    @type minor: int
+    @param minor: the drbd minor whose settings we change
+    @type kbytes: int
+    @param kbytes: the speed in kbytes/second
+    @rtype: boolean
+    @return: the success of the operation
+
+    """
+    result = utils.RunCmd(["drbdsetup", cls._DevPath(minor), "syncer",
+                           "-r", "%d" % kbytes, "--create-device"])
+    if result.failed:
+      logging.error("Can't change syncer rate: %s - %s",
+                    result.fail_reason, result.output)
+    return not result.failed
+

   def SetSyncSpeed(self, kbytes):
     """Set the speed of the DRBD syncer.
 
   def SetSyncSpeed(self, kbytes):
     """Set the speed of the DRBD syncer.
 

+    @type kbytes: int
+    @param kbytes: the speed in kbytes/second
+    @rtype: boolean
+    @return: the success of the operation
+

     """
     """

-    children_result = super(DRBD8, self).SetSyncSpeed(kbytes)

     if self.minor is None:
     if self.minor is None:

-      logger.Info("Instance not attached to a device")
+      logging.info("Not attached during SetSyncSpeed")

       return False
       return False

-    result = utils.RunCmd(["drbdsetup", self.dev_path, "syncer", "-r", "%d" %
-                           kbytes])
-    if result.failed:
-      logger.Error("Can't change syncer rate: %s - %s" %
-                   (result.fail_reason, result.output))
-    return not result.failed and children_result
+    children_result = super(DRBD8, self).SetSyncSpeed(kbytes)
+    return self._SetMinorSyncSpeed(self.minor, kbytes) and children_result

 
   def GetProcStatus(self):
     """Return device data from /proc.
 
   def GetProcStatus(self):
     """Return device data from /proc.

@@ -1156,8 +1174,6 @@ class DRBD8(BaseDRBD):
   def GetSyncStatus(self):
     """Returns the sync status of the device.
 
   def GetSyncStatus(self):
     """Returns the sync status of the device.
 

-    Returns:
-     (sync_percent, estimated_time, is_degraded)

 
     If sync_percent is None, it means all is ok
     If estimated_time is None, it means we can't esimate
 
     If sync_percent is None, it means all is ok
     If estimated_time is None, it means we can't esimate

@@ -1170,6 +1186,9 @@ class DRBD8(BaseDRBD):
     We compute the ldisk parameter based on wheter we have a local
     disk or not.
 
     We compute the ldisk parameter based on wheter we have a local
     disk or not.
 

+    @rtype: tuple
+    @return: (sync_percent, estimated_time, is_degraded, ldisk)
+

     """
     if self.minor is None and not self.Attach():
       raise errors.BlockDeviceError("Can't attach to device in GetSyncStatus")
     """
     if self.minor is None and not self.Attach():
       raise errors.BlockDeviceError("Can't attach to device in GetSyncStatus")

@@ -1188,7 +1207,7 @@ class DRBD8(BaseDRBD):
 
     """
     if self.minor is None and not self.Attach():
 
     """
     if self.minor is None and not self.Attach():

-      logger.Error("DRBD cannot attach to a device during open")
+      logging.error("DRBD cannot attach to a device during open")

       return False
     cmd = ["drbdsetup", self.dev_path, "primary"]
     if force:
       return False
     cmd = ["drbdsetup", self.dev_path, "primary"]
     if force:

@@ -1196,7 +1215,7 @@ class DRBD8(BaseDRBD):
     result = utils.RunCmd(cmd)
     if result.failed:
       msg = ("Can't make drbd device primary: %s" % result.output)
     result = utils.RunCmd(cmd)
     if result.failed:
       msg = ("Can't make drbd device primary: %s" % result.output)

-      logger.Error(msg)
+      logging.error(msg)

       raise errors.BlockDeviceError(msg)
 
   def Close(self):
       raise errors.BlockDeviceError(msg)
 
   def Close(self):

@@ -1206,24 +1225,142 @@ class DRBD8(BaseDRBD):
 
     """
     if self.minor is None and not self.Attach():
 
     """
     if self.minor is None and not self.Attach():

-      logger.Info("Instance not attached to a device")
+      logging.info("Instance not attached to a device")

       raise errors.BlockDeviceError("Can't find device")
     result = utils.RunCmd(["drbdsetup", self.dev_path, "secondary"])
     if result.failed:
       msg = ("Can't switch drbd device to"
              " secondary: %s" % result.output)
       raise errors.BlockDeviceError("Can't find device")
     result = utils.RunCmd(["drbdsetup", self.dev_path, "secondary"])
     if result.failed:
       msg = ("Can't switch drbd device to"
              " secondary: %s" % result.output)

-      logger.Error(msg)
+      logging.error(msg)

       raise errors.BlockDeviceError(msg)
 
       raise errors.BlockDeviceError(msg)
 

+  def DisconnectNet(self):
+    """Removes network configuration.
+
+    This method shutdowns the network side of the device.
+
+    The method will wait up to a hardcoded timeout for the device to
+    go into standalone after the 'disconnect' command before
+    re-configuring it, as sometimes it takes a while for the
+    disconnect to actually propagate and thus we might issue a 'net'
+    command while the device is still connected. If the device will
+    still be attached to the network and we time out, we raise an
+    exception.
+
+    """
+    if self.minor is None:
+      raise errors.BlockDeviceError("DRBD disk not attached in re-attach net")
+
+    if None in (self._lhost, self._lport, self._rhost, self._rport):
+      raise errors.BlockDeviceError("DRBD disk missing network info in"
+                                    " DisconnectNet()")
+
+    ever_disconnected = self._ShutdownNet(self.minor)
+    timeout_limit = time.time() + self._NET_RECONFIG_TIMEOUT
+    sleep_time = 0.100 # we start the retry time at 100 miliseconds
+    while time.time() < timeout_limit:
+      status = self.GetProcStatus()
+      if status.is_standalone:
+        break
+      # retry the disconnect, it seems possible that due to a
+      # well-time disconnect on the peer, my disconnect command might
+      # be ingored and forgotten
+      ever_disconnected = self._ShutdownNet(self.minor) or ever_disconnected
+      time.sleep(sleep_time)
+      sleep_time = min(2, sleep_time * 1.5)
+
+    if not status.is_standalone:
+      if ever_disconnected:
+        msg = ("Device did not react to the"
+               " 'disconnect' command in a timely manner")
+      else:
+        msg = ("Can't shutdown network, even after multiple retries")
+      raise errors.BlockDeviceError(msg)
+
+    reconfig_time = time.time() - timeout_limit + self._NET_RECONFIG_TIMEOUT
+    if reconfig_time > 15: # hardcoded alert limit
+      logging.debug("DRBD8.DisconnectNet: detach took %.3f seconds",
+                    reconfig_time)
+
+  def AttachNet(self, multimaster):
+    """Reconnects the network.
+
+    This method connects the network side of the device with a
+    specified multi-master flag. The device needs to be 'Standalone'
+    but have valid network configuration data.
+
+    Args:
+      - multimaster: init the network in dual-primary mode
+
+    """
+    if self.minor is None:
+      raise errors.BlockDeviceError("DRBD disk not attached in AttachNet")
+
+    if None in (self._lhost, self._lport, self._rhost, self._rport):
+      raise errors.BlockDeviceError("DRBD disk missing network info in"
+                                    " AttachNet()")
+
+    status = self.GetProcStatus()
+
+    if not status.is_standalone:
+      raise errors.BlockDeviceError("Device is not standalone in AttachNet")
+
+    return self._AssembleNet(self.minor,
+                             (self._lhost, self._lport,
+                              self._rhost, self._rport),
+                             "C", dual_pri=multimaster)
+

   def Attach(self):
   def Attach(self):

-    """Find a DRBD device which matches our config and attach to it.
+    """Check if our minor is configured.
+
+    This doesn't do any device configurations - it only checks if the
+    minor is in a state different from Unconfigured.
+
+    Note that this function will not change the state of the system in
+    any way (except in case of side-effects caused by reading from
+    /proc).
+
+    """
+    used_devs = self.GetUsedDevs()
+    if self._aminor in used_devs:
+      minor = self._aminor
+    else:
+      minor = None
+
+    self._SetFromMinor(minor)
+    return minor is not None
+
+  def Assemble(self):
+    """Assemble the drbd.
+
+    Method:
+      - if we have a configured device, we try to ensure that it matches
+        our config
+      - if not, we create it from zero
+
+    """
+    result = super(DRBD8, self).Assemble()
+    if not result:
+      return result
+
+    self.Attach()
+    if self.minor is None:
+      # local device completely unconfigured
+      return self._FastAssemble()
+    else:
+      # we have to recheck the local and network status and try to fix
+      # the device
+      return self._SlowAssemble()
+
+  def _SlowAssemble(self):
+    """Assembles the DRBD device from a (partially) configured device.

 
     In case of partially attached (local device matches but no network
     setup), we perform the network attach. If successful, we re-test
     the attach if can return success.
 
     """
 
     In case of partially attached (local device matches but no network
     setup), we perform the network attach. If successful, we re-test
     the attach if can return success.
 
     """

-    for minor in self._GetUsedDevs():
+    for minor in (self._aminor,):

       info = self._GetDevInfo(self._GetShowData(minor))
       match_l = self._MatchesLocal(info)
       match_r = self._MatchesNet(info)
       info = self._GetDevInfo(self._GetShowData(minor))
       match_l = self._MatchesLocal(info)
       match_r = self._MatchesNet(info)

@@ -1233,7 +1370,10 @@ class DRBD8(BaseDRBD):
         res_r = self._AssembleNet(minor,
                                   (self._lhost, self._lport,
                                    self._rhost, self._rport),
         res_r = self._AssembleNet(minor,
                                   (self._lhost, self._lport,
                                    self._rhost, self._rport),

-                                  "C")
+                                  constants.DRBD_NET_PROTOCOL,
+                                  hmac=constants.DRBD_HMAC_ALG,
+                                  secret=self._secret
+                                  )

         if res_r:
           if self._MatchesNet(self._GetDevInfo(self._GetShowData(minor))):
             break
         if res_r:
           if self._MatchesNet(self._GetDevInfo(self._GetShowData(minor))):
             break

@@ -1261,7 +1401,10 @@ class DRBD8(BaseDRBD):
         # local storage (i.e. one or more of the _[lr](host|port) is
         # None)
         if (self._AssembleNet(minor, (self._lhost, self._lport,
         # local storage (i.e. one or more of the _[lr](host|port) is
         # None)
         if (self._AssembleNet(minor, (self._lhost, self._lport,

-                                      self._rhost, self._rport), "C") and
+                                      self._rhost, self._rport),
+                              constants.DRBD_NET_PROTOCOL,
+                              hmac=constants.DRBD_HMAC_ALG,
+                              secret=self._secret) and

             self._MatchesNet(self._GetDevInfo(self._GetShowData(minor)))):
           break
 
             self._MatchesNet(self._GetDevInfo(self._GetShowData(minor)))):
           break
 

@@ -1271,35 +1414,15 @@ class DRBD8(BaseDRBD):
     self._SetFromMinor(minor)
     return minor is not None
 
     self._SetFromMinor(minor)
     return minor is not None
 

-  def Assemble(self):
-    """Assemble the drbd.
+  def _FastAssemble(self):
+    """Assemble the drbd device from zero.

 
 

-    Method:
-      - if we have a local backing device, we bind to it by:
-        - checking the list of used drbd devices
-        - check if the local minor use of any of them is our own device
-        - if yes, abort?
-        - if not, bind
-      - if we have a local/remote net info:
-        - redo the local backing device step for the remote device
-        - check if any drbd device is using the local port,
-          if yes abort
-        - check if any remote drbd device is using the remote
-          port, if yes abort (for now)
-        - bind our net port
-        - bind the remote net port
+    This is run when in Assemble we detect our minor is unused.

 
     """
 
     """

-    self.Attach()
-    if self.minor is not None:
-      logger.Info("Already assembled")
-      return True
-
-    result = super(DRBD8, self).Assemble()
-    if not result:
-      return result
-
-    minor = self._FindUnusedMinor()
+    # TODO: maybe completely tear-down the minor (drbdsetup ... down)
+    # before attaching our own?
+    minor = self._aminor

     need_localdev_teardown = False
     if self._children and self._children[0] and self._children[1]:
       result = self._AssembleLocal(minor, self._children[0].dev_path,
     need_localdev_teardown = False
     if self._children and self._children[0] and self._children[1]:
       result = self._AssembleLocal(minor, self._children[0].dev_path,

@@ -1311,11 +1434,13 @@ class DRBD8(BaseDRBD):
       result = self._AssembleNet(minor,
                                  (self._lhost, self._lport,
                                   self._rhost, self._rport),
       result = self._AssembleNet(minor,
                                  (self._lhost, self._lport,
                                   self._rhost, self._rport),

-                                 "C")
+                                 constants.DRBD_NET_PROTOCOL,
+                                 hmac=constants.DRBD_HMAC_ALG,
+                                 secret=self._secret)

       if not result:
         if need_localdev_teardown:
           # we will ignore failures from this
       if not result:
         if need_localdev_teardown:
           # we will ignore failures from this

-          logger.Error("net setup failed, tearing down local device")
+          logging.error("net setup failed, tearing down local device")

           self._ShutdownAll(minor)
         return False
     self._SetFromMinor(minor)
           self._ShutdownAll(minor)
         return False
     self._SetFromMinor(minor)

@@ -1331,7 +1456,7 @@ class DRBD8(BaseDRBD):
     """
     result = utils.RunCmd(["drbdsetup", cls._DevPath(minor), "detach"])
     if result.failed:
     """
     result = utils.RunCmd(["drbdsetup", cls._DevPath(minor), "detach"])
     if result.failed:

-      logger.Error("Can't detach local device: %s" % result.output)
+      logging.error("Can't detach local device: %s", result.output)

     return not result.failed
 
   @classmethod
     return not result.failed
 
   @classmethod

@@ -1343,7 +1468,7 @@ class DRBD8(BaseDRBD):
     """
     result = utils.RunCmd(["drbdsetup", cls._DevPath(minor), "disconnect"])
     if result.failed:
     """
     result = utils.RunCmd(["drbdsetup", cls._DevPath(minor), "disconnect"])
     if result.failed:

-      logger.Error("Can't shutdown network: %s" % result.output)
+      logging.error("Can't shutdown network: %s", result.output)

     return not result.failed
 
   @classmethod
     return not result.failed
 
   @classmethod

@@ -1355,7 +1480,7 @@ class DRBD8(BaseDRBD):
     """
     result = utils.RunCmd(["drbdsetup", cls._DevPath(minor), "down"])
     if result.failed:
     """
     result = utils.RunCmd(["drbdsetup", cls._DevPath(minor), "down"])
     if result.failed:

-      logger.Error("Can't shutdown drbd device: %s" % result.output)
+      logging.error("Can't shutdown drbd device: %s", result.output)

     return not result.failed
 
   def Shutdown(self):
     return not result.failed
 
   def Shutdown(self):

@@ -1363,7 +1488,7 @@ class DRBD8(BaseDRBD):
 
     """
     if self.minor is None and not self.Attach():
 
     """
     if self.minor is None and not self.Attach():

-      logger.Info("DRBD device not attached to a device during Shutdown")
+      logging.info("DRBD device not attached to a device during Shutdown")

       return True
     if not self._ShutdownAll(self.minor):
       return False
       return True
     if not self._ShutdownAll(self.minor):
       return False

@@ -1387,15 +1512,24 @@ class DRBD8(BaseDRBD):
     """
     if len(children) != 2:
       raise errors.ProgrammerError("Invalid setup for the drbd device")
     """
     if len(children) != 2:
       raise errors.ProgrammerError("Invalid setup for the drbd device")

+    # check that the minor is unused
+    aminor = unique_id[4]
+    proc_info = cls._MassageProcData(cls._GetProcData())
+    if aminor in proc_info:
+      status = DRBD8Status(proc_info[aminor])
+      in_use = status.is_in_use
+    else:
+      in_use = False
+    if in_use:
+      raise errors.BlockDeviceError("DRBD minor %d already in use at"
+                                    " Create() time" % aminor)

     meta = children[1]
     meta.Assemble()
     if not meta.Attach():
       raise errors.BlockDeviceError("Can't attach to meta device")
     if not cls._CheckMetaSize(meta.dev_path):
       raise errors.BlockDeviceError("Invalid meta device size")
     meta = children[1]
     meta.Assemble()
     if not meta.Attach():
       raise errors.BlockDeviceError("Can't attach to meta device")
     if not cls._CheckMetaSize(meta.dev_path):
       raise errors.BlockDeviceError("Invalid meta device size")

-    cls._InitMeta(cls._FindUnusedMinor(), meta.dev_path)
-    if not cls._IsValidMeta(meta.dev_path):
-      raise errors.BlockDeviceError("Cannot initalize meta device")
+    cls._InitMeta(aminor, meta.dev_path)

     return cls(unique_id, children)
 
   def Grow(self, amount):
     return cls(unique_id, children)
 
   def Grow(self, amount):

@@ -1433,6 +1567,7 @@ class FileStorage(BlockDev):
       raise ValueError("Invalid configuration data %s" % str(unique_id))
     self.driver = unique_id[0]
     self.dev_path = unique_id[1]
       raise ValueError("Invalid configuration data %s" % str(unique_id))
     self.driver = unique_id[0]
     self.dev_path = unique_id[1]

+    self.Attach()

 
   def Assemble(self):
     """Assemble the device.
 
   def Assemble(self):
     """Assemble the device.

@@ -1473,8 +1608,8 @@ class FileStorage(BlockDev):
   def Remove(self):
     """Remove the file backing the block device.
 
   def Remove(self):
     """Remove the file backing the block device.
 

-    Returns:
-      boolean indicating wheter removal of file was successful or not.
+    @rtype: boolean
+    @return: True if the removal was successful

 
     """
     if not os.path.exists(self.dev_path):
 
     """
     if not os.path.exists(self.dev_path):

@@ -1483,8 +1618,7 @@ class FileStorage(BlockDev):
       os.remove(self.dev_path)
       return True
     except OSError, err:
       os.remove(self.dev_path)
       return True
     except OSError, err:

-      logger.Error("Can't remove file '%s': %s"
-                   % (self.dev_path, err))
+      logging.error("Can't remove file '%s': %s", self.dev_path, err)

       return False
 
   def Attach(self):
       return False
 
   def Attach(self):

@@ -1492,36 +1626,34 @@ class FileStorage(BlockDev):
 
     Check if this file already exists.
 
 
     Check if this file already exists.
 

-    Returns:
-      boolean indicating if file exists or not.
+    @rtype: boolean
+    @return: True if file exists

 
     """
 
     """

-    if os.path.exists(self.dev_path):
-      return True
-    return False
+    self.attached = os.path.exists(self.dev_path)
+    return self.attached

 
   @classmethod
   def Create(cls, unique_id, children, size):
     """Create a new file.
 
 
   @classmethod
   def Create(cls, unique_id, children, size):
     """Create a new file.
 

-    Args:
-      children:
-      size: integer size of file in MiB
+    @param size: the size of file in MiB

 
 

-    Returns:
-      A ganeti.bdev.FileStorage object.
+    @rtype: L{bdev.FileStorage}
+    @return: an instance of FileStorage

 
     """
 
     """

+    # TODO: decide whether we should check for existing files and
+    # abort or not

     if not isinstance(unique_id, (tuple, list)) or len(unique_id) != 2:
       raise ValueError("Invalid configuration data %s" % str(unique_id))
     dev_path = unique_id[1]
     try:
       f = open(dev_path, 'w')
     if not isinstance(unique_id, (tuple, list)) or len(unique_id) != 2:
       raise ValueError("Invalid configuration data %s" % str(unique_id))
     dev_path = unique_id[1]
     try:
       f = open(dev_path, 'w')

-    except IOError, err:
-      raise errors.BlockDeviceError("Could not create '%'" % err)
-    else:

       f.truncate(size * 1024 * 1024)
       f.close()
       f.truncate(size * 1024 * 1024)
       f.close()

+    except IOError, err:
+      raise errors.BlockDeviceError("Error in file creation: %" % str(err))

 
     return FileStorage(unique_id, children)
 
 
     return FileStorage(unique_id, children)
 

@@ -1543,27 +1675,25 @@ def FindDevice(dev_type, unique_id, children):
   if dev_type not in DEV_MAP:
     raise errors.ProgrammerError("Invalid block device type '%s'" % dev_type)
   device = DEV_MAP[dev_type](unique_id, children)
   if dev_type not in DEV_MAP:
     raise errors.ProgrammerError("Invalid block device type '%s'" % dev_type)
   device = DEV_MAP[dev_type](unique_id, children)

-  if not device.Attach():
+  if not device.attached:

     return None
     return None

-  return  device
+  return device

 
 
 
 

-def AttachOrAssemble(dev_type, unique_id, children):
+def Assemble(dev_type, unique_id, children):

   """Try to attach or assemble an existing device.
 
   """Try to attach or assemble an existing device.
 

-  This will attach to an existing assembled device or will assemble
-  the device, as needed, to bring it fully up.
+  This will attach to assemble the device, as needed, to bring it
+  fully up. It must be safe to run on already-assembled devices.

 
   """
   if dev_type not in DEV_MAP:
     raise errors.ProgrammerError("Invalid block device type '%s'" % dev_type)
   device = DEV_MAP[dev_type](unique_id, children)
 
   """
   if dev_type not in DEV_MAP:
     raise errors.ProgrammerError("Invalid block device type '%s'" % dev_type)
   device = DEV_MAP[dev_type](unique_id, children)

-  if not device.Attach():
-    device.Assemble()
-    if not device.Attach():
-      raise errors.BlockDeviceError("Can't find a valid block device for"
-                                    " %s/%s/%s" %
-                                    (dev_type, unique_id, children))
+  if not device.Assemble():
+    raise errors.BlockDeviceError("Can't find a valid block device for"
+                                  " %s/%s/%s" %
+                                  (dev_type, unique_id, children))

   return device
 
 
   return device