Synnefo » snf-ganeti

import re

import subprocess

import random

from ganeti import errors

from ganeti import utils

from ganeti import ssh

  result = utils.RunCmd([constants.MASTER_SCRIPT, "-d", "start"])

  if result.failed:

    return False

  return True

  result = utils.RunCmd([constants.MASTER_SCRIPT, "-d", "stop"])

  if result.failed:

    return False

  return True

    priv_key, pub_key, auth_keys = ssh.GetUserFiles(constants.GANETI_RUNAS,

                                                    mkdir=True)

  except errors.OpExecError, err:

    return False

  for name, content in [(priv_key, sshkey), (pub_key, sshpub)]:

  try:

    priv_key, pub_key, auth_keys = ssh.GetUserFiles(constants.GANETI_RUNAS)

    return

  f = open(pub_key, 'r')

                         "--separator=%s" % sep,

                         "-olv_name,lv_size,lv_attr", vg_name])

  if result.failed:

    return result.output

  valid_line_re = re.compile("^ *([^|]+)\|([0-9.]+)\|([^|]{6})\|?$")

    line = line.strip()

    match = valid_line_re.match(line)

    if not match:

      continue

    name, size, attr = match.groups()

    inactive = attr[4] == '-'

                         "--separator=|",

                         "--options=lv_name,lv_size,devices,vg_name"])

  if result.failed:

    return {}

  def parse_dev(dev):

  try:

    names = hypervisor.GetHypervisor().ListInstances()

  except errors.HypervisorError, err:

    raise

  return names

  os_device = instance.FindDisk(os_disk)

  if os_device is None:

    return False

  swap_device = instance.FindDisk(swap_disk)

  if swap_device is None:

    return False

  real_os_dev = _RecursiveFindBD(os_device)

  result = utils.RunCmd(command)

  if result.failed:

    return False

  return True

  os_device = instance.FindDisk(os_disk)

  if os_device is None:

    return False

  swap_device = instance.FindDisk(swap_disk)

  if swap_device is None:

    return False

  real_os_dev = _RecursiveFindBD(os_device)

  result = utils.RunCmd(command)

  if result.failed:

    return False

  return True

                         "--nosuffix", "--units=m", "--separator=:", vg_name])

  if retval.failed:

    return retdic

  valarr = retval.stdout.strip().rstrip(':').split(':')

  if len(valarr) == 3:

        "pv_count": int(valarr[2]),

        }

    except ValueError, err:

  else:

  return retdic

  try:

    hyper.StartInstance(instance, block_devices, extra_args)

  except errors.HypervisorError, err:

    return False

  return True

  try:

    hyper.StopInstance(instance)

  except errors.HypervisorError, err:

    return False

  # test every 10secs for 2min

    time.sleep(10)

  else:

    # the shutdown did not succeed

    try:

      hyper.StopInstance(instance, force=True)

    except errors.HypervisorError, err:

      return False

    time.sleep(1)

    if instance.name in GetInstanceList():

      return False

  return True

  running_instances = GetInstanceList()

  if instance.name not in running_instances:

    return False

  hyper = hypervisor.GetHypervisor()

    try:

      hyper.RebootInstance(instance)

    except errors.HypervisorError, err:

      return False

  elif reboot_type == constants.INSTANCE_REBOOT_HARD:

    try:

      ShutdownInstance(instance)

      StartInstance(instance, extra_args)

    except errors.HypervisorError, err:

      return False

  else:

    raise errors.ParameterError("reboot_type invalid")

    hyper.MigrateInstance(instance, target, live)

  except errors.HypervisorError, err:

    msg = "Failed to migrate instance: %s" % str(err)

    return (False, msg)

  return (True, "Migration successfull")

  try:

    device = bdev.FindDevice(disk.dev_type, disk.physical_id, clist)

    if device is not None:

      device.Remove()

  except errors.BlockDeviceError, err:

    pass

  if on_primary or disk.AssembleOnSecondary():

    if not device.Assemble():

      errorstring = "Can't assemble device after creation"

      raise errors.BlockDeviceError("%s, very unusual event - check the node"

                                    " daemon logs" % errorstring)

    device.SetSyncSpeed(constants.SYNC_SPEED)

    rdev = _RecursiveFindBD(disk, allow_partial=True)

  except errors.BlockDeviceError, err:

    # probably can't attach

    rdev = None

  if rdev is not None:

    r_path = rdev.dev_path

        if children.count(None) >= mcn:

          raise

        cdev = None

      children.append(cdev)

  if as_primary or disk.AssembleOnSecondary():

  """

  parent_bdev = _RecursiveFindBD(parent_cdev, allow_partial=True)

  if parent_bdev is None:

    return False

  new_bdevs = [_RecursiveFindBD(disk) for disk in new_cdevs]

  if new_bdevs.count(None) > 0:

    return False

  parent_bdev.AddChildren(new_bdevs)

  return True

  """

  parent_bdev = _RecursiveFindBD(parent_cdev)

  if parent_bdev is None:

    return False

  devs = []

  for disk in new_cdevs:

    if rpath is None:

      bd = _RecursiveFindBD(disk)

      if bd is None:

        return False

      else:

        devs.append(bd.dev_path)

  """

  if not os.path.isabs(file_name):

    return False

  allowed_files = [

    ]

  allowed_files.extend(ssconf.SimpleStore().GetFileList())

  if file_name not in allowed_files:

    return False

  utils.WriteFile(file_name, data=data, mode=mode, uid=uid, gid=gid,

      try:

        f_names = utils.ListVisibleFiles(dir_name)

      except EnvironmentError, err:

        break

      for name in f_names:

        try:

  result = utils.RunCmd(command)

  if result.failed:

    return False

  return True

  os_device = instance.FindDisk(os_disk)

  if os_device is None:

    return False

  swap_device = instance.FindDisk(swap_disk)

  if swap_device is None:

    return False

  real_os_dev = _RecursiveFindBD(os_device)

  result = utils.RunCmd(command)

  if result.failed:

    return False

  return True

        # cache? for now, we only lose lvm data when we rename, which

        # is less critical than DRBD or MD

    except errors.BlockDeviceError, err:

      result = False

  return result

  base_file_storage_dir = ssconf.SimpleStore().GetFileStorageDir()

  if (not os.path.commonprefix([file_storage_dir, base_file_storage_dir]) ==

      base_file_storage_dir):

    return None

  return file_storage_dir

  else:

    if os.path.exists(file_storage_dir):

      if not os.path.isdir(file_storage_dir):

        result = False,

    else:

      try:

        os.makedirs(file_storage_dir, 0750)

      except OSError, err:

        result = False,

  return result

  else:

    if os.path.exists(file_storage_dir):

      if not os.path.isdir(file_storage_dir):

        result = False,

      # deletes dir only if empty, otherwise we want to return False

      try:

        os.rmdir(file_storage_dir)

      except OSError, err:

        result = False,

  return result

        try:

          os.rename(old_file_storage_dir, new_file_storage_dir)

        except OSError, err:

          result =  False,

      else:

        result = False,

    else:

      if os.path.exists(old_file_storage_dir):

        result = False,

  return result

            fd.close()

          except EnvironmentError, err:

            # just log the error

            pass

    return result == 0, output

    """

    if dev_path is None:

      return

    fpath = cls._ConvertPath(dev_path)

    if on_primary:

    try:

      utils.WriteFile(fpath, data=fdata)

    except EnvironmentError, err:

  @classmethod

  def RemoveCache(cls, dev_path):

    """

    if dev_path is None:

      return

    fpath = cls._ConvertPath(dev_path)

    try:

      utils.RemoveFile(fpath)

    except EnvironmentError, err: