Synnefo » snf-ganeti

  """

  _CleanDirectory(constants.QUEUE_DIR, exclude=[constants.JOB_QUEUE_LOCK_FILE])

  _CleanDirectory(constants.JOB_QUEUE_ARCHIVE_DIR)

def GetMasterInfo():

  for consumption here or from the node daemon.

  @rtype: tuple

  @raise RPCFail: in case of errors

  """

    master_node = cfg.GetMasterNode()

  except errors.ConfigurationError, err:

    _Fail("Cluster configuration incomplete", exc=True)

def StartMaster(start_daemons):

  based on the start_daemons parameter.

  @type start_daemons: boolean

      daemons (ganeti-masterd and ganeti-rapi)

  @rtype: None

  if payload:

    _Fail("; ".join(payload))

def StopMaster(stop_daemons):

  """Deactivate this node as master.

    for daemon in constants.RAPI_PID, constants.MASTERD_PID:

      utils.KillProcess(utils.ReadPidFile(utils.DaemonPidFileName(daemon)))

def AddNode(dsa, dsapub, rsa, rsapub, sshkey, sshpub):

  """Joins this node to the cluster.

  utils.RunCmd([constants.SSH_INITD_SCRIPT, "restart"])

def LeaveCluster():

  """Cleans up and remove the current node.

  finally:

    f.close()

def VerifyNode(what, cluster_name):

      used_minors = str(err)

    result[constants.NV_DRBDLIST] = used_minors

def GetVolumeList(vg_name):

      size of the volume

  """

def NodeVolumes():

      'vg': line[3].strip(),

    }

def BridgesExist(bridges_list):

  if missing:

    _Fail("Missing bridges %s", ", ".join(missing))

def GetInstanceList(hypervisor_list):

  """Provides a list of instances.

    output['state'] = iinfo[4]

    output['time'] = iinfo[5]

def GetInstanceMigratable(instance):

    if not os.path.islink(link_name):

      _Fail("Instance %s was not restarted since ganeti 1.2.5", iname)

def GetAllInstancesInfo(hypervisor_list):

  """Gather data about all instances.

                    " with different parameters", name)

        output[name] = value

def InstanceOsAdd(instance, reinstall):

  @param instance: Instance whose OS is to be installed

  @type reinstall: boolean

  @param reinstall: whether this is an instance reinstall

  """

  inst_os = OSFromDisk(instance.os)

  create_env = OSEnvironment(instance)

  if reinstall:

    create_env['INSTANCE_REINSTALL'] = "1"

    _Fail("OS create script failed (%s), last lines in the"

          " log file:\n%s", result.fail_reason, "\n".join(lines), log=False)

def RunRenameInstance(instance, old_name):

  """Run the OS rename script for an instance.

    _Fail("OS rename script failed (%s), last lines in the"

          " log file:\n%s", result.fail_reason, "\n".join(lines), log=False)

def _GetVGInfo(vg_name):

  """Get informations about the volume group.

  @type instance: L{objects.Instance}

  @param instance: the instance object

  """

  running_instances = GetInstanceList([instance.hypervisor])

  if instance.name in running_instances:

  try:

    block_devices = _GatherAndLinkBlockDevs(instance)

    _RemoveBlockDevLinks(instance.name, instance.disks)

    _Fail("Hypervisor error: %s", err, exc=True)

def InstanceShutdown(instance):

  """Shut an instance down.

  @type instance: L{objects.Instance}

  @param instance: the instance object

  """

  hv_name = instance.hypervisor

  running_instances = GetInstanceList([hv_name])

  hyper = hypervisor.GetHypervisor(hv_name)

  try:

    hyper.StopInstance(instance)

  except errors.HypervisorError, err:

  # test every 10secs for 2min

    time.sleep(10)

  else:

    # the shutdown did not succeed

    try:

      hyper.StopInstance(instance, force=True)

    except errors.HypervisorError, err:

    time.sleep(1)

    if instance.name in GetInstanceList([hv_name]):

def InstanceReboot(instance, reboot_type):

      - the other reboot type (L{constants.INSTANCE_REBOOT_HARD})

        is not accepted here, since that mode is handled

        differently

  """

  running_instances = GetInstanceList([instance.hypervisor])

      _Fail("Failed to soft reboot instance %s: %s", instance.name, err)

  elif reboot_type == constants.INSTANCE_REBOOT_HARD:

    try:

      return StartInstance(instance)

    except errors.HypervisorError, err:

      _Fail("Failed to hard reboot instance %s: %s", instance.name, err)

  else:

    _Fail("Invalid reboot_type received: %s", reboot_type)

def MigrationInfo(instance):

  """Gather information about an instance to be migrated.

    info = hyper.MigrationInfo(instance)

  except errors.HypervisorError, err:

    _Fail("Failed to fetch migration information: %s", err, exc=True)

def AcceptInstance(instance, info, target):

    hyper.AcceptInstance(instance, info, target)

  except errors.HypervisorError, err:

    _Fail("Failed to accept instance: %s", err, exc=True)

def FinalizeMigration(instance, info, success):

    hyper.FinalizeMigration(instance, info, success)

  except errors.HypervisorError, err:

    _Fail("Failed to finalize migration: %s", err, exc=True)

def MigrateInstance(instance, target, live):

    hyper.MigrateInstance(instance.name, target, live)

  except errors.HypervisorError, err:

    _Fail("Failed to migrate instance: %s", err, exc=True)

def BlockdevCreate(disk, size, owner, on_primary, info):

  device.SetInfo(info)

def BlockdevRemove(disk):

  """

  msgs = []

  try:

    rdev = _RecursiveFindBD(disk)

  except errors.BlockDeviceError, err:

      rdev.Remove()

    except errors.BlockDeviceError, err:

      msgs.append(str(err))

      DevCacheManager.RemoveCache(r_path)

  if disk.children:

    for child in disk.children:

    _Fail("; ".join(msgs))

def _RecursiveAssembleBD(disk, owner, as_primary):

  """Activate a block device for an instance.

  except errors.BlockDeviceError, err:

    _Fail("Error while assembling disk: %s", err, exc=True)

def BlockdevShutdown(disk):

  @type disk: L{objects.Disk}

  @param disk: the description of the disk we should

      shutdown

  """

  msgs = []

  r_dev = _RecursiveFindBD(disk)

  if r_dev is not None:

    r_path = r_dev.dev_path

      DevCacheManager.RemoveCache(r_path)

    except errors.BlockDeviceError, err:

      msgs.append(str(err))

  if disk.children:

    for child in disk.children:

    _Fail("; ".join(msgs))

def BlockdevAddchildren(parent_cdev, new_cdevs):

  @param parent_cdev: the disk to which we should add children

  @type new_cdevs: list of L{objects.Disk}

  @param new_cdevs: the list of children which we should add

  """

  parent_bdev = _RecursiveFindBD(parent_cdev)

  if new_bdevs.count(None) > 0:

    _Fail("Can't find new device(s) to add: %s:%s", new_bdevs, new_cdevs)

  parent_bdev.AddChildren(new_bdevs)

def BlockdevRemovechildren(parent_cdev, new_cdevs):

  @param parent_cdev: the disk from which we should remove children

  @type new_cdevs: list of L{objects.Disk}

  @param new_cdevs: the list of children which we should remove

  """

  parent_bdev = _RecursiveFindBD(parent_cdev)

    else:

      devs.append(rpath)

  parent_bdev.RemoveChildren(devs)

def BlockdevGetmirrorstatus(disks):

    if rbd is None:

      _Fail("Can't find device %s", dsk)

    stats.append(rbd.CombinedSyncStatus())

def _RecursiveFindBD(disk):

  except errors.BlockDeviceError, err:

    _Fail("Failed to find device: %s", err, exc=True)

  if rbd is None:

def UploadFile(file_name, data, mode, uid, gid, atime, mtime):

  @param atime: the atime to set on the file (can be None)

  @type mtime: float

  @param mtime: the mtime to set on the file (can be None)

  """

  if not os.path.isabs(file_name):

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

                  atime=atime, mtime=mtime)

def WriteSsconfFiles(values):

  """

  ssconf.SimpleStore().WriteFiles(values)

def _ErrnoOrStr(err):

          diagnose = os_inst

        result.append((name, os_path, status, diagnose))

def _TryOSFromDisk(name, base_dir=None):

  except errors.BlockDeviceError, err:

    _Fail("Failed to grow block device: %s", err, exc=True)

def BlockdevSnapshot(disk):

  """Create a snapshot copy of a block device.

    r_dev = _RecursiveFindBD(disk)

    if r_dev is not None:

      # let's stay on the safe side and ask for the full size, for now

    else:

      _Fail("Cannot find block device %s", disk)

  else:

  @type idx: int

  @param idx: the index of the disk in the instance's disk list,

      used to export to the OS scripts environment

  """

  export_env = OSEnvironment(instance)

    _Fail("OS snapshot export command '%s' returned error: %s"

          " output: %s", command, result.fail_reason, result.output)

def FinalizeExport(instance, snap_disks):

  """Write out the export configuration information.

  @param snap_disks: list of snapshot block devices, which

      will be used to get the actual name of the dump file

  """

  destdir = os.path.join(constants.EXPORT_DIR, instance.name + ".new")

  shutil.rmtree(finaldestdir, True)

  shutil.move(destdir, finaldestdir)

def ExportInfo(dest):

  """Get export configuration information.

      not config.has_section(constants.INISECT_INS)):

    _Fail("Export info file doesn't have the required fields")

def ImportOSIntoInstance(instance, src_node, src_images, cluster_name):

  if final_result:

    _Fail("; ".join(final_result), log=False)

def ListExports():

  """

  if os.path.isdir(constants.EXPORT_DIR):

  else:

    _Fail("No exports directory")

  @type export: str

  @param export: the name of the export to remove

  """

  target = os.path.join(constants.EXPORT_DIR, export)

  except EnvironmentError, err:

    _Fail("Error while removing the export: %s", err, exc=True)

def BlockdevRename(devlist):

  """Rename a list of block devices.

      result = False

  if not result:

    _Fail("; ".join(msgs))

def _TransformFileStorageDir(file_storage_dir):

    except OSError, err:

      _Fail("Cannot create file storage directory '%s': %s",

            file_storage_dir, err, exc=True)

def RemoveFileStorageDir(file_storage_dir):

      _Fail("Cannot remove file storage directory '%s': %s",

            file_storage_dir, err)

def RenameFileStorageDir(old_file_storage_dir, new_file_storage_dir):

  """Rename the file storage directory.

    if os.path.exists(old_file_storage_dir):

      _Fail("Cannot rename '%s' to '%s': both locations exist",

            old_file_storage_dir, new_file_storage_dir)

def _EnsureJobQueueFile(file_name):

  # Write and replace the file atomically

  utils.WriteFile(file_name, data=_Decompress(content))

def JobQueueRename(old, new):

  """Renames a job queue file.

  utils.RenameFile(old, new, mkdir=True)

def JobQueueSetDrainFlag(drain_flag):

  """Set the drain flag for the queue.

  else:

    utils.RemoveFile(constants.JOB_QUEUE_DRAIN_FILE)

def BlockdevClose(instance_name, disks):

  """Closes the given block devices.

  else:

    if instance_name:

      _RemoveBlockDevLinks(instance_name, disks)

def ValidateHVParams(hvname, hvparams):

  @param hvname: the hypervisor name

  @type hvparams: dict

  @param hvparams: the hypervisor parameters to be validated

  """

  try:

    hv_type = hypervisor.GetHypervisor(hvname)

    hv_type.ValidateParameters(hvparams)

  except errors.HypervisorError, err:

    _Fail(str(err), log=False)

    if err.errno != errno.ENOENT:

      _Fail("Error while backing up cluster file: %s", err, exc=True)

  utils.RemoveFile(constants.CLUSTER_CONF_FILE)

def _FindDisks(nodes_ip, disks):

    except errors.BlockDeviceError, err:

      _Fail("Can't change network configuration to standalone mode: %s",

            err, exc=True)

def DrbdAttachNet(nodes_ip, disks, instance_name, multimaster):

        rd.Open()

      except errors.BlockDeviceError, err:

        _Fail("Can't change to primary mode: %s", err)

def DrbdWaitSync(nodes_ip, disks):

    if stats.sync_percent is not None:

      min_resync = min(min_resync, stats.sync_percent)

def PowercycleNode(hypervisor_type):

    # if we can't fork, we'll pretend that we're in the child process

    pid = 0

  if pid > 0:

  time.sleep(5)

  hyper.PowercycleNode()

      dir_contents = utils.ListVisibleFiles(dir_name)

    except OSError, err:

      # FIXME: must log output in case of failures

    # we use the standard python sort order,

    # so 00name is the recommended naming scheme

          rrval = constants.HKR_SUCCESS

      rr.append(("%s/%s" % (subdir, relname), rrval, output))

class IAllocatorRunner(object):

    finally:

      os.unlink(fin_name)

class DevCacheManager(object):