Synnefo » snf-ganeti » ganeti-local

    @param port: TCP/UDP port

    """

    self._data.listen_port = port

  def GetListenPort(self):

from ganeti import daemon

from ganeti import errors

# We contributed the AsyncNotifier class back to python-pyinotify, and it's

# part of their codebase since version 0.8.7. This code can be removed once

# we'll be ready to depend on python-pyinotify >= 0.8.7

      # we don't want to report such volumes as existing, since they

      # don't really hold data

      continue

  return lvs

      config.set(constants.INISECT_INS, "nic%d_%s" % (nic_count, param),

                 "%s" % nic.nicparams.get(param, None))

  # TODO: redundant: on load can read nics until it doesn't exist

  disk_total = 0

  for disk_count, disk in enumerate(snap_disks):

      config.set(constants.INISECT_INS, "disk%d_size" % disk_count,

                 ("%d" % disk.size))

  # New-style hypervisor/backend parameters

    else:

      _Fail("Unknown hooks phase '%s'", phase)

    subdir = "%s-%s.d" % (hpath, suffix)

    dir_name = utils.PathJoin(self._BASE_DIR, subdir)

                                  is_degraded=is_degraded,

                                  ldisk_status=ldisk_status)

  def SetInfo(self, text):

    """Update metadata with info text.

    pvs_info.sort()

    pvs_info.reverse()

    if compat.any(":" in v for v in pvlist):

      _ThrowError("Some of your PVs have the invalid character ':' in their"

                  " name, this is not supported - please filter them out"

                  " in lvm.conf using either 'filter' or 'preferred_names'")

    current_pvs = len(pvlist)

    stripes = min(current_pvs, constants.LVM_STRIPECOUNT)

    super(DRBD8, self).__init__(unique_id, children, size)

    self.major = self._DRBD_MAJOR

    version = self._GetVersion(self._GetProcData())

      _ThrowError("Mismatch in DRBD kernel version and requested ganeti"

                  " usage: kernel is %s.%s, ganeti wants 8.x",

                  version["k_major"], version["k_minor"])

    # this also converts the value to an int

    number = pyp.Word(pyp.nums).setParseAction(lambda s, l, t: int(t[0]))

    defa = pyp.Literal("_is_default").suppress()

    dbl_quote = pyp.Literal('"').suppress()

                               " entries: %s" % invalid_hvs,

                               errors.ECODE_INVAL)

  ipcls = None

  if primary_ip_version == constants.IP4_VERSION:

    ipcls = netutils.IP4Address

  master_ip = sstore.GetMasterIP()

  total_timeout = 30

  # Here we have a phase where no master should be running

  def _check_ip():

    if netutils.TcpPing(master_ip, constants.DEFAULT_NODED_PORT):

                         type="keyval", default={},

                         help="Backend parameters")

HYPERVISOR_OPT = cli_option("-H", "--hypervisor-parameters", dest="hypervisor",

                            help="Hypervisor and hypervisor options, in the"

  @return: a string with the formatted timestamp

  """

    return "?"

  sec, usec = ts

  return time.strftime("%F %T", time.localtime(sec)) + ".%06d" % usec

    t3 = time.time()

    ToStdout("C:op     %4d" % op_cnt)

    ToStdout("C:job    %4d" % job_cnt)

  return 0

  "allocator": "iallocator",

  }

def Main():

  return GenericMain(commands, aliases=aliases)

                 if isinstance(elem, tuple)] or [0])

  for elem in data:

    if isinstance(elem, basestring):

    elif isinstance(elem, tuple):

      key, value = elem

      spacer = "%*s" % (max_tlen - len(key), "")

    elif isinstance(elem, list):

def ShowInstanceConfig(opts, args):

    buf.write("  Operating system: %s\n" % instance["os"])

    FormatParameterDict(buf, instance["os_instance"], instance["os_actual"],

                        level=2)

      buf.write("  Allocated network port: %s\n" %

                compat.TryToRoman(instance["network_port"],

                                  convert=opts.roman_integers))

      raise errors.OpExecError("Check of out-of-band payload failed due to %s" %

                               utils.CommaJoin(errs))

class _OsQuery(_QueryBase):

  FIELDS = query.OS_FIELDS

  if disk_template not in req_size_dict:

    raise errors.ProgrammerError("Disk template '%s' size requirement"

  return req_size_dict[disk_template]

  if disk_template not in req_size_dict:

    raise errors.ProgrammerError("Disk template '%s' size requirement"

  return req_size_dict[disk_template]

        # 'fake' LV disks with the old data, plus the new unique_id

        tmp_disks = [objects.Disk.FromDict(v.ToDict()) for v in disks]

        rename_to = []

          rename_to.append(t_dsk.logical_id)

          t_dsk.logical_id = (t_dsk.logical_id[0], a_dsk[constants.IDISK_ADOPT])

          self.cfg.SetDiskID(t_dsk, pnode_name)

      if msg:

        # Assume the primary node is unreachable and go ahead

        self.warn.append("Can't get info from primary node %s: %s" %

      elif not isinstance(pninfo.payload.get("memory_free", None), int):

        self.warn.append("Node data from primary node %s doesn't contain"

                         " free memory information" % pnode)

    return result

class LUGroupRemove(LogicalUnit):

  HPATH = "group-remove"

  HTYPE = constants.HTYPE_GROUP

    return False

  return True

def _any(seq):

  """Returns True if any element of the iterable are True.

    return True

  return False

try:

  # pylint: disable-msg=E0601

  # pylint: disable-msg=W0622

except NameError:

  any = _any

def partition(seq, pred=bool): # pylint: disable-msg=W0622

  """Partition a list in two, based on the given predicate.

    raise errors.ConfdMagicError("UDP payload contains an unkown fourcc")

  return payload[_FOURCC_LEN:]

    elif peer_cnt < 5:

      return peer_cnt - 1

    else:

  def WaitForReply(self, salt, timeout=constants.CONFD_CLIENT_EXPIRE_TIMEOUT):

    """Wait for replies to a given request.

                cluster.SimpleFillND(nodegroup.ndparams),

                constants.NDS_PARAMETER_TYPES)

    # drbd minors check

    _, duplicates = self._UnlockedComputeDRBDMap()

    for node, minor, instance_a, instance_b in duplicates:

# Wipe

DD_CMD = "dd"

MAX_WIPE_CHUNK = 1024 # 1GB

MIN_WIPE_CHUNK_PERCENT = 10

ADOPTABLE_BLOCKDEV_ROOT = "/dev/disk/"

# keep RUN_GANETI_DIR first here, to make sure all get created when the node

# daemon is started (this takes care of RUN_DIR being tmpfs)

LOCK_DIR = _autoconf.LOCALSTATEDIR + "/lock"

SSCONF_LOCK_FILE = LOCK_DIR + "/ganeti-ssconf.lock"

# User-id pool lock directory

#: Dictionary with special field cases and their verbose/terse formatting

RSS_DESCRIPTION = {

  RS_UNKNOWN: ("(unknown)", "??"),

  RS_OFFLINE: ("(offline)", "*"),

  RS_UNAVAIL: ("(unavail)", "-"),

  }

# User-id pool minimum/maximum acceptable user-ids.

UIDPOOL_UID_MIN = 0

# Name or path of the pgrep command

PGREP = "pgrep"

  error = GetEncodedError(result)

  if error:

    (errcls, args) = error

    """

    try:

    except KeyError:

      # Need to create new client

      client = self._GetHttpClientCreator()(self._curl_config_fn)

          key = splitfields[0].strip()

          val = splitfields[1].strip()

          if key == "MemTotal":

          elif key in ("MemFree", "Buffers", "Cached"):

          elif key == "Active":

    except (ValueError, TypeError), err:

      raise errors.HypervisorError("Failed to compute memory usage: %s" %

                                   (err,))

    arg_list = cmdline.split("\x00")

    while arg_list:

      if arg == "-name":

        instance = arg_list.pop(0)

      elif arg == "-m":

    """

    _, v_major, v_min, _ = self._GetKVMVersion()

    kvm = constants.KVM_PATH

    kvm_cmd = [kvm]

    # used just by the vnc server, if enabled

    @return: tuple (name, id, memory, vcpus, stat, times)

    """

    result = None

    for data in xm_list:

      if data[0] == instance_name:

# Dict used to convert from a string representing an IP family to an IP

# version

  "inet": constants.IP4_VERSION,

  "inet6": constants.IP6_VERSION,

  }

    assert 0 <= prefix <= cls.iplen

    target_int = cls._GetIPIntFromString(subnet[0])

    # Convert prefix netmask to integer value of netmask

    # Calculate hostmask

    # Calculate network address by and'ing netmask

    network_int = target_int & netmask_int

    # Calculate broadcast address by or'ing hostmask

    """

    if self.dev_type == constants.LD_LV:

    elif self.dev_type in constants.LDS_DRBD:

      node_a, node_b, port, minor_a, minor_b = self.logical_id[:5]

      val = "<DRBD8("

      node = self.primary_node

    if lvmap is None:

      ret = lvmap

    else:

      if not node in lvmap:

    for dev in devs:

      if dev.dev_type == constants.LD_LV:

      elif dev.dev_type in constants.LDS_DRBD:

        if dev.children:

    ("name", ht.NoDefault, ht.TMaybeString, None),

    ]

# Test opcodes

class OpTestDelay(OpCode):

  """Sleeps for a configured amount of time.

  (field_id, field_uri) = uri_fields

  def _MapId(m_id):

  # Make sure the result is sorted, makes it nicer to look at and simplifies

  # unittests.

    })

class R_2_groups_name_modify(baserlib.R_Generic):

  """/2/groups/[group_name]/modify resource.

      _priv_lock.release()

  return _priv

      logging.debug(err)

      return

    if answer is not None:

      try:

        self.enqueue_send(ip, port, confd.PackMagic(answer))

  """

  _MAX_UNHANDLED = 1

  def __init__(self, server, connected_socket, client_address, family):

    daemon.AsyncTerminatedMessageStream.__init__(self, connected_socket,

                                                 client_address,

    """

    return backend.DemoteFromMC()

  @staticmethod

  def perspective_node_powercycle(params):

    """Tries to powercycle the nod.

    hypervisor_type = params[0]

    return backend.PowercycleNode(hypervisor_type)

  # cluster --------------------------

  @staticmethod

  try:

    fd.seek(0, 2)

    pos = fd.tell()

    fd.seek(pos, 0)

    raw_data = fd.read()

  finally:

  __slots__ = ["exit_code", "signal", "stdout", "stderr",

               "failed", "fail_reason", "cmd"]

  def __init__(self, exit_code, signal_, stdout, stderr, cmd, timeout_action,

               timeout):

    self.cmd = cmd

  """

  rdict = {}

  def helper(*innerargs):

    # pylint: disable-msg=W0142

    result = rdict["result"] = fn(*innerargs)

  resu = ""

  for char in text:

    c = ord(char)

      resu += r"\t"

    elif char == "\n":

      resu += r"\n"

    """

    my_name = netutils.Hostname.GetSysName()

    self.confd_client.SendRequest(req, async=False, coverage=-1)

    timed_out, _, _ = self.confd_client.WaitForReply(req.rsalt)

    if not timed_out:

  2: ""

  }

class InstanceDown(Exception):

  """The checked instance was not up"""

  """

  if args:

    msg = msg % args

                                  LOG_HEADERS.get(indent, "  "), msg))

  sys.stdout.flush()

      Log(msg, indent=2)

      op = opcodes.OpInstanceCreate(instance_name=instance,

                                    disk_template=self.opts.disk_template,

                                    nics=self.opts.nics,

                                    mode=constants.INSTANCE_CREATE,

                                        ignore_failures=True)

      imp_dir = utils.PathJoin(constants.EXPORT_DIR, full_name)

      imp_op = opcodes.OpInstanceCreate(instance_name=instance,

                                        disk_template=self.opts.disk_template,

                                        nics=self.opts.nics,

                                        mode=constants.INSTANCE_IMPORT,

      if opts.do_replace1 and opts.disk_template in constants.DTS_INT_MIRROR:

        self.BurnReplaceDisks1D8()

      if (opts.do_replace2 and len(self.nodes) > 2 and

        self.BurnReplaceDisks2()

      if (opts.disk_template in constants.DTS_GROWABLE and

    constants.INSTST_RUNNING,

    constants.INSTST_ERRORUP,

    ])

  def __init__(self, clusters, pause_period, groups, restart, params,

               stop_instances):

    """Initialize object with sane defaults and infos required.

    if self.restart == _RESTART_UP:

      raise NotImplementedError

  def Setup(self):

    """Sets up our end so we can do the merger.

  WriteLog("SUCCESS: command output follows", logfile)

  for line in output.split("\n"):

  WriteLog("command execution completed", logfile)

  session.close()

#: Minimum partition size to be considered (1 GB)

PART_MINSIZE = 1024 * 1024 * 1024

class Error(Exception):

  """Generic exception"""

                    action="store_true", default=False,

                    help="use sfdisk instead of parted")

  options, args = parser.parse_args()

  if len(args) != 1:

    Usage()

  match = PART_RE.match(disk)

  if match:

    # this is a partition, which resides in /sys/block under a different name

  return "/sys/block/%s" % disk

    result = ExecCommand("parted -s /dev/%s mklabel %s" % (name, label_type))

    if result.failed:

      raise OperationalError("Critical: failed to create %s label on %s" %

    result = ExecCommand("parted -s /dev/%s mkpart pri ext2 1 100%%" % name)

    if result.failed:

      raise OperationalError("Critical: failed to create partition on %s" %

                      "  LV count: %s, size: %s, free: %s." %

                      (vgname, lv_count, vg_size, vg_free))

  disklist = ValidateDiskList(options)

  for disk in disklist: