Synnefo » snf-ganeti

    master_ip = cfg.GetMasterIP()

    master_node = cfg.GetMasterNode()

  except errors.ConfigurationError, err:

  return master_netdev, master_ip, master_node

  for hname in hypervisor_list:

    iinfo = hypervisor.GetHypervisor(hname).GetAllInstancesInfo()

    if iinfo:

        value = {

          'memory': memory,

          'vcpus': vcpus,

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

        }

    except ValueError, err:

  else:

    logging.error("vgs output has the wrong number of fields (expected"

                  " three): %s", str(valarr))

  """Remove the block device symlinks belonging to the given instance.

  """

    link_name = _GetBlockDevSymlinkPath(instance_name, idx)

    if os.path.islink(link_name):

      try:

      try:

        f_names = utils.ListVisibleFiles(dir_name)

      except EnvironmentError, err:

        break

      for name in f_names:

        os_path = os.path.sep.join([dir_name, name])

  min_resync = 100

  alldone = True

  for rd in bdevs:

    stats = rd.GetProcStatus()

    if not (stats.is_connected or stats.is_in_resync):

  hyper = hypervisor.GetHypervisor(hypervisor_type)

  try:

    pid = os.fork()

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

    pid = 0

  if pid > 0:

    dir_name = "%s/%s" % (self._BASE_DIR, subdir)

    try:

      dir_contents = utils.ListVisibleFiles(dir_name)

      # FIXME: must log output in case of failures

      return rr

    try:

      utils.WriteFile(fpath, data=fdata)

    except EnvironmentError, err:

  @classmethod

  def RemoveCache(cls, dev_path):

    try:

      utils.RemoveFile(fpath)

    except EnvironmentError, err:

import os

import os.path

import time

import re

import platform

import logging

import copy

from ganeti import ssh

from ganeti import utils

from ganeti import locking

from ganeti import constants

from ganeti import objects

from ganeti import serializer

from ganeti import ssconf

  """

  if node is None:

  _CheckNicsBridgesExist(lu, instance.nics, node)

      "master": cluster.master_node,

      "default_hypervisor": cluster.default_hypervisor,

      "enabled_hypervisors": cluster.enabled_hypervisors,

      "beparams": cluster.beparams,

      "nicparams": cluster.nicparams,

      "candidate_pool_size": cluster.candidate_pool_size,

      bridge = nic.get("bridge", None)

      link = nic.get("link", None)

      if bridge and link:

      elif bridge and nic_mode == constants.NIC_MODE_ROUTED:

        raise errors.OpPrereqError("Cannot pass 'bridge' on a routed nic")

      elif bridge:

      nic_bridge = nic_dict.get('bridge', None)

      nic_link = nic_dict.get('link', None)

      if nic_bridge and nic_link:

      elif nic_bridge and nic_bridge.lower() == constants.VALUE_NONE:

        nic_dict['bridge'] = None

      elif nic_link and nic_link.lower() == constants.VALUE_NONE:

import os

import re

from ganeti import errors

    constants.HV_ACPI: hv_base.NO_CHECK,

    constants.HV_SERIAL_CONSOLE: hv_base.NO_CHECK,

    constants.HV_VNC_BIND_ADDRESS: \

     "the VNC bind address must be either a valid IP address or an absolute"

     " pathname", None, None),

    constants.HV_VNC_TLS: hv_base.NO_CHECK,

    hv_base.BaseHypervisor.__init__(self)

    # Let's make sure the directories we need exist, even if the RUN_DIR lives

    # in a tmpfs filesystem or has been otherwise wiped out.

    utils.EnsureDirs(dirs)

  def _InstancePidAlive(self, instance_name):

    phase = constants.HOOKS_PHASE_POST

    hpath = constants.HOOKS_NAME_CFGUPDATE

    nodes = [self.lu.cfg.GetMasterNode()]

           "OS", "Node", "Cluster", "FillDict"]

def FillDict(defaults_dict, custom_dict):

def UpgradeGroupedParams(target, defaults):

    """Checks that this disk is correctly configured.

    """

    if self.mode not in constants.DISK_ACCESS_SET:

class Instance(TaggableObject):

    if target[key] in allowed_values:

      continue

      raise errors.ProgrammerError(msg)

      if not isinstance(target[key], basestring):

        if isinstance(target[key], bool) and not target[key]:

          target[key] = ''

        else:

          msg = "'%s' (value %s) is not a valid string" % (key, target[key])

          raise errors.TypeEnforcementError(msg)

      if isinstance(target[key], basestring) and target[key]:

        if target[key].lower() == constants.VALUE_FALSE:

          target[key] = False

        target[key] = True

      else:

        target[key] = False

      try:

        target[key] = ParseUnit(target[key])

      except errors.UnitParseError, err:

        msg = "'%s' (value %s) is not a valid size. error: %s" % \

              (key, target[key], err)

        raise errors.TypeEnforcementError(msg)

      try:

        target[key] = int(target[key])

      except (ValueError, TypeError):

  @param name: the daemon name used to derive the pidfile name

  """

  pidfilename = DaemonPidFileName(name)

  # TODO: we could check here that the file contains our pid

  try: