Synnefo » snf-ganeti

  clist = []

  if disk.children:

    for child in disk.children:

      if on_primary or disk.AssembleOnSecondary():

        # we need the children open in case the device itself has to

        # be assembled

      clist.append(crdev)

  try:

    device = bdev.Create(disk.dev_type, disk.physical_id, clist, size)

    return False, "Can't create block device: %s" % str(err)

  if on_primary or disk.AssembleOnSecondary():

    device.SetSyncSpeed(constants.SYNC_SPEED)

    if on_primary or disk.OpenOnSecondary():

    DevCacheManager.UpdateCache(device.dev_path, owner,

                                on_primary, disk.iv_name)

        if children.count(None) >= mcn:

          raise

        cdev = None

      children.append(cdev)

  if as_primary or disk.AssembleOnSecondary():

      C{True} for secondary nodes

  """

  result = "no error information"

  try:

    result = _RecursiveAssembleBD(disk, owner, as_primary)

    if isinstance(result, bdev.BlockDev):

      result = result.dev_path

  except errors.BlockDeviceError, err:

    result = "Error while assembling disk: %s" % str(err)

  return (status, result)

        this method is idempotent

    """

  def Attach(self):

    """Find a device which matches our config and attach to it.

    """

    result = utils.RunCmd(["lvchange", "-ay", self.dev_path])

    if result.failed:

  def Shutdown(self):

    """Shutdown the device.

            backend, meta, "0", "-e", "detach", "--create-device"]

    result = utils.RunCmd(args)

    if result.failed:

  @classmethod

  def _AssembleNet(cls, minor, net_info, protocol,

    if None in net_info:

      # we don't want network connection and actually want to make

      # sure its shutdown

    # Workaround for a race condition. When DRBD is doing its dance to

    # establish a connection with its peer, it also sends the

      args.extend(["-a", hmac, "-x", secret])

    result = utils.RunCmd(args)

    if result.failed:

    timeout = time.time() + 10

    ok = False

      ok = True

      break

    if not ok:

  def AddChildren(self, devices):

    """Add a disk to the DRBD device.

      raise errors.BlockDeviceError("Invalid meta device size")

    self._InitMeta(self._FindUnusedMinor(), meta.dev_path)

    self._children = devices

  def RemoveChildren(self, devices):

        _ThrowError("drbd%d: mismatch in local storage (%s != %s) in"

                    " RemoveChildren", self.minor, dev, child.dev_path)

    self._children = []

  @classmethod

      _ThrowError("drbd%d: DRBD disk missing network info in"

                  " DisconnectNet()", 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:

      # retry the disconnect, it seems possible that due to a

      # well-time disconnect on the peer, my disconnect command might

      # be ingored and forgotten

      time.sleep(sleep_time)

      sleep_time = min(2, sleep_time * 1.5)

    if not status.is_standalone:

      _ThrowError("drbd%d: device is not standalone in AttachNet", self.minor)

  def Attach(self):

    """Check if our minor is configured.

      - if not, we create it from zero

    """

    self.Attach()

    if self.minor is None:

      # local device completely unconfigured

    else:

      # we have to recheck the local and network status and try to fix

      # the device

  def _SlowAssemble(self):

    """Assembles the DRBD device from a (partially) configured device.

    the attach if can return success.

    """

    for minor in (self._aminor,):

      info = self._GetDevInfo(self._GetShowData(minor))

      match_l = self._MatchesLocal(info)

      match_r = self._MatchesNet(info)

      if match_l and match_r:

        break

      if match_l and not match_r and "local_addr" not in info:

      if match_r and "local_dev" not in info:

      # this case must be considered only if we actually have local

      # storage, i.e. not in diskless mode, because all diskless

        # else, even though its local storage is ours; as we own the

        # drbd space, we try to disconnect from the remote peer and

        # reconnect to our correct one

        # note: _AssembleNet also handles the case when we don't want

        # local storage (i.e. one or more of the _[lr](host|port) is

        # None)

          break

    else:

      minor = None

    self._SetFromMinor(minor)

  def _FastAssemble(self):

    """Assemble the drbd device from zero.

    This is run when in Assemble we detect our minor is unused.

    """

    minor = self._aminor

    if self._children and self._children[0] and self._children[1]:

    if self._lhost and self._lport and self._rhost and self._rport:

    self._SetFromMinor(minor)

  @classmethod

  def _ShutdownLocal(cls, minor):

    """

    result = utils.RunCmd(["drbdsetup", cls._DevPath(minor), "detach"])

    if result.failed:

  @classmethod

  def _ShutdownNet(cls, minor):

    """

    result = utils.RunCmd(["drbdsetup", cls._DevPath(minor), "disconnect"])

    if result.failed:

  @classmethod

  def _ShutdownAll(cls, minor):

    """

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

  def Shutdown(self):

    """Shutdown the device.

  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)

  return device