Synnefo » snf-ganeti

from ganeti import constants

class BlockDev(object):

  """Block device abstract class.

    vg_name, lv_name = unique_id

    pvs_info = cls.GetPVInfo(vg_name)

    if not pvs_info:

    pvs_info.sort()

    pvs_info.reverse()

    # The size constraint should have been checked from the master before

    # calling the create function.

    if free_size < size:

    result = utils.RunCmd(["lvcreate", "-L%dm" % size, "-n%s" % lv_name,

                           vg_name] + pvlist)

    if result.failed:

    return LogicalVolume(unique_id, children)

  @staticmethod

                                   (self._vg_name, new_vg))

    result = utils.RunCmd(["lvrename", new_vg, self._lv_name, new_name])

    if result.failed:

    self._lv_name = new_name

    self.dev_path = "/dev/%s/%s" % (self._vg_name, self._lv_name)

    pvs_info = self.GetPVInfo(self._vg_name)

    if not pvs_info:

    pvs_info.sort()

    pvs_info.reverse()

    free_size, pv_name = pvs_info[0]

    if free_size < size:

    result = utils.RunCmd(["lvcreate", "-L%dm" % size, "-s",

                           "-n%s" % snap_name, self.dev_path])

    if result.failed:

    return snap_name

    result = utils.RunCmd(["lvchange", "--addtag", text,

                           self.dev_path])

    if result.failed:

  def Grow(self, amount):

    """Grow the logical volume.

                             "-L", "+%dm" % amount, self.dev_path])

      if not result.failed:

        return

class DRBD8Status(object):

    finally:

      stat.close()

    if not data:

    return data

  @staticmethod

    self.major = self._DRBD_MAJOR

    version = self._GetVersion()

    if version['k_major'] != 8 :

    if len(children) not in (0, 2):

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

    result = utils.RunCmd(["drbdmeta", "--force", cls._DevPath(minor),

                           "v08", dev_path, "0", "create-md"])

    if result.failed:

  @classmethod

  def _FindUnusedMinor(cls):

    try:

      results = bnf.parseString(out)

    except pyp.ParseException, err:

    # and massage the results into our desired format

    for section in results:

    """

    if self.minor is None:

    if len(devices) != 2:

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

    if "local_dev" in info:

    backend, meta = devices

    if backend.dev_path is None or meta.dev_path is None:

    backend.Open()

    meta.Open()

    if not self._CheckMetaSize(meta.dev_path):

    """

    if self.minor is None:

    # early return if we don't actually have backing storage

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

    if "local_dev" not in info:

      return

    if len(self._children) != 2:

    if self._children.count(None) == 2: # we don't actually have children :)

      return

    if len(devices) != 2:

    for child, dev in zip(self._children, devices):

      if dev != child.dev_path:

    if not self._ShutdownLocal(self.minor):

      raise errors.BlockDeviceError("Can't detach from local storage")

    """

    if self.minor is None:

    proc_info = self._MassageProcData(self._GetProcData())

    if self.minor not in proc_info:

    return DRBD8Status(proc_info[self.minor])

  def GetSyncStatus(self):

    """

    if self.minor is None and not self.Attach():

    stats = self.GetProcStatus()

    ldisk = not stats.is_disk_uptodate

    is_degraded = not stats.is_connected

      cmd.append("-o")

    result = utils.RunCmd(cmd)

    if result.failed:

  def Close(self):

    """Make the local state secondary.

    """

    if self.minor is None and not self.Attach():

    result = utils.RunCmd(["drbdsetup", self.dev_path, "secondary"])

    if result.failed:

  def DisconnectNet(self):

    """Removes network configuration.

    """

    if self.minor is None:

    if None in (self._lhost, self._lport, self._rhost, self._rport):

    ever_disconnected = self._ShutdownNet(self.minor)

    timeout_limit = time.time() + self._NET_RECONFIG_TIMEOUT

    if not status.is_standalone:

      if ever_disconnected:

               " 'disconnect' command in a timely manner")

      else:

    reconfig_time = time.time() - timeout_limit + self._NET_RECONFIG_TIMEOUT

    if reconfig_time > 15: # hardcoded alert limit

  def AttachNet(self, multimaster):

    """Reconnects the network.

    """

    if self.minor is None:

    if None in (self._lhost, self._lport, self._rhost, self._rport):

    status = self.GetProcStatus()

    if not status.is_standalone:

    return self._AssembleNet(self.minor,

                             (self._lhost, self._lport,

    else:

      in_use = False

    if in_use:

    meta = children[1]

    meta.Assemble()

    if not meta.Attach():

    """

    if self.minor is None:

    if len(self._children) != 2 or None in self._children:

    self._children[0].Grow(amount)

    result = utils.RunCmd(["drbdsetup", self.dev_path, "resize"])

    if result.failed:

class FileStorage(BlockDev):

      f.truncate(size * 1024 * 1024)

      f.close()

    except IOError, err:

    return FileStorage(unique_id, children)