Synnefo » snf-ganeti

"""

# [C0103] Invalid name build-bash-completion

import os

    for opt in opts:

      # While documented, these variables aren't seen as public attributes by

      opt.all_names = sorted(opt._short_opts + opt._long_opts)

  def _FindFirstArgument(self, sw):

"""

# C0103: Invalid name import-export

import errno

  @return: Arguments to program

  """

  parser = optparse.OptionParser(usage=("%%prog <status-file> {%s|%s}" %

                                        (constants.IEM_IMPORT,

        errmsg = "Exited with status %s" % (child.returncode, )

      status_file.SetExitStatus(child.returncode, errmsg)

      logging.exception("Unhandled error occurred")

      status_file.SetExitStatus(constants.EXIT_FAILURE,

                                "Unhandled error occurred: %s" % (err, ))

import logging

try:

  from pyinotify import pyinotify

except ImportError:

  import pyinotify

  """An asyncore dispatcher for inotify events.

  """

  def __init__(self, watch_manager, default_proc_fun=None, map=None):

    """Initializes this class.

    @param watch_manager: inotify watch manager

    """

    # no need to call the parent's constructor

    self.watch_manager = watch_manager

    if self._watch_handle is not None and self.RemoveWatch(self._watch_handle):

      self._watch_handle = None

  # this overrides a method in pyinotify.ProcessEvent

  def process_IN_IGNORED(self, event):

    # Since we monitor a single file rather than the directory it resides in,

    self._watch_handle = None

    self._callback(False)

  # this overrides a method in pyinotify.ProcessEvent

  def process_IN_MODIFY(self, event):

    # This gets called when the monitored file is modified. Note that this

"""

# E1103: %s %r has no %r member (but some types could not be

# inferred), because the _TryOSFromDisk returns either (True, os_obj)

    utils.RemoveFile(constants.CONFD_HMAC_KEY)

    utils.RemoveFile(constants.RAPI_CERT_FILE)

    utils.RemoveFile(constants.NODED_CERT_FILE)

    logging.exception("Error while removing cluster secrets")

  result = utils.RunCmd([constants.DAEMON_UTIL, "stop", constants.CONFD])

  """

  # TODO: remove the obsolete "size" argument

  clist = []

  if disk.children:

    for child in disk.children:

        # we need the children open in case the device itself has to

        # be assembled

        try:

          crdev.Open()

        except errors.BlockDeviceError, err:

          _Fail("Can't make child '%s' read-write: %s", child, err)

  try:

    result = _RecursiveAssembleBD(disk, owner, as_primary)

    if isinstance(result, bdev.BlockDev):

      result = result.dev_path

      if as_primary:

        _SymlinkBlockDev(owner, result, idx)

  # ensure the child is running on ram

  try:

    utils.Mlockall()

    pass

  time.sleep(5)

  hyper.PowercycleNode()

      hooks_base_dir = constants.HOOKS_BASE_DIR

    # yeah, _BASE_DIR is not valid for attributes, we use it like a

    # constant

  def RunHooks(self, hpath, phase, env):

    """Run the scripts in the hooks directory.

      self.est_time = None

  """Base DRBD class.

  This class contains a few bits of common functionality between the

    """

    # TODO: Rewrite to not use a for loop just because there is 'break'

    net_data = (self._lhost, self._lport, self._rhost, self._rport)

    for minor in (self._aminor,):

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

  return file_storage_dir

                master_netdev, file_storage_dir, shared_file_storage_dir,

                candidate_pool_size, secondary_ip=None, vg_name=None,

                beparams=None, nicparams=None, ndparams=None, hvparams=None,

from ganeti import ht

from ganeti import rapi

COMMON_PARAM_NAMES = map(compat.fst, opcodes.OpCode.OP_PARAMS)

  The expression's result is included as a literal.

  """

  # W0102: Dangerous default value as argument

  # W0142: Used * or ** magic

  # W0613: Unused argument

  try:

    result = eval(code, EVAL_NS)

    msg = inliner.reporter.error("Failed to evaluate %r: %s" % (code, err),

                                 line=lineno)

    return ([inliner.problematic(rawtext, rawtext, msg)], [msg])

class _Argument:

    self.min = min

    self.max = max

  Value can be any of the ones passed to the constructor.

  """

  def __init__(self, min=0, max=None, choices=None):

    _Argument.__init__(self, min=min, max=max)

    self.choices = choices

  SubmitOpCode(op, opts=opts)

  """OptParsers custom converter for units.

  """

  return kv_dict

  """Custom parser for ident:key=val,key=val options.

  This will store the parsed values as a tuple (ident, {key: val}). As such,

  return retval

  """Custom parser class for key=val,key=val options.

  This will store the parsed values as a dict {key: val}.

  return _SplitKeyVal(opt, value)

  """Custom parser for yes/no options.

  This will store the parsed value as either True or False.

  if unitfields is None:

    unitfields = []

  format_fields = []

  for field in fields:

"""Backup related commands"""

# W0401: Wildcard import ganeti.cli

# W0613: Unused argument, since all functions follow the same API

# W0614: Unused import %s from wildcard import (since we need cli)

"""Cluster related commands"""

# W0401: Wildcard import ganeti.cli

# W0613: Unused argument, since all functions follow the same API

# W0614: Unused import %s from wildcard import (since we need cli)

    cl = GetClient()

    cl.QueryClusterInfo()

    return 0

    return 1

      OpenSSL.crypto.load_certificate(OpenSSL.crypto.FILETYPE_PEM,

                                      rapi_cert_pem)

      ToStderr("Can't load new RAPI certificate from %s: %s" %

               (rapi_cert_filename, str(err)))

      return 1

    try:

      OpenSSL.crypto.load_privatekey(OpenSSL.crypto.FILETYPE_PEM, rapi_cert_pem)

      ToStderr("Can't load new RAPI private key from %s: %s" %

               (rapi_cert_filename, str(err)))

      return 1

  if cds_filename:

    try:

      cds = utils.ReadFile(cds_filename)

      ToStderr("Can't load new cluster domain secret from %s: %s" %

               (cds_filename, str(err)))

      return 1

"""Debugging commands"""

# W0401: Wildcard import ganeti.cli

# W0614: Unused import %s from wildcard import (since we need cli)

# C0103: Invalid name gnt-backup

    ToStdout("Loading...")

  for job_idx in range(opts.rep_job):

    for fname in args:

      op_data = simplejson.loads(utils.ReadFile(fname))

      op_list = [opcodes.OpCode.LoadOpCode(val) for val in op_data]

      op_list = op_list * opts.rep_op

  return 0

  """List all locks.

  @param opts: the command line options selected by the user

"""Node group related commands"""

# W0401: Wildcard import ganeti.cli

# W0614: Unused import %s from wildcard import (since we need cli)

"""Instance related commands"""

# W0401: Wildcard import ganeti.cli

# W0614: Unused import %s from wildcard import (since we need cli)

# C0103: Invalid name gnt-instance

  @raise errors.OpPrereqError: for invalid input parameters

  """

  if client is None:

    client = GetClient()

  json_filename = args[0]

  try:

    instance_data = simplejson.loads(utils.ReadFile(json_filename))

    ToStderr("Can't parse the instance definition file: %s" % str(err))

    return 1

  # Iterate over the instances and do:

  #  * Populate the specs with default value

  #  * Validate the instance specs

  for name in i_names:

    specs = instance_data[name]

    specs = _PopulateWithDefaults(specs)

"""Job related commands"""

# W0401: Wildcard import ganeti.cli

# W0613: Unused argument, since all functions follow the same API

# W0614: Unused import %s from wildcard import (since we need cli)

"""Node related commands"""

# W0401: Wildcard import ganeti.cli

# W0613: Unused argument, since all functions follow the same API

# W0614: Unused import %s from wildcard import (since we need cli)

"""OS scripts related commands"""

# W0401: Wildcard import ganeti.cli

# W0613: Unused argument, since all functions follow the same API

# W0614: Unused import %s from wildcard import (since we need cli)

"""Module implementing the master-side code."""

# W0201 since most LU attributes are defined in CheckPrereq or similar

# functions

from ganeti import opcodes

from ganeti import ht

class ResultWithJobs:

    # Used to force good behavior when calling helper functions

    self.recalculate_locks = {}

    # logging

    # support for dry-run

    self.dry_run_result = None

    # support for generic debug attribute

    """

    # API must be kept, thus we ignore the unused argument and could

    # be a function warnings

    return lu_result

  def _ExpandAndLockInstance(self):

    del self.recalculate_locks[locking.LEVEL_NODE]

  """Simple LU which runs no hooks.

  This LU is intended as a parent for other LogicalUnits which will

  try:

    hm.RunPhase(constants.HOOKS_PHASE_POST, nodes=[node_name])

  except:

    lu.LogWarning("Errors occurred running hooks on %s" % node_name)

  }

  if override:

    args.update(override)

def _AdjustCandidatePool(lu, exceptions):

  try:

    cert = OpenSSL.crypto.load_certificate(OpenSSL.crypto.FILETYPE_PEM,

                                           utils.ReadFile(filename))

    return (LUClusterVerifyConfig.ETYPE_ERROR,

            "Failed to load X509 certificate %s: %s" % (filename, err))

    if args:

      msg = msg % args

    # then format the whole message

      msg = "%s:%s:%s:%s:%s" % (ltype, etxt, itype, item, msg)

    else:

      if item:

        item = ""

      msg = "%s: %s%s: %s" % (ltype, itype, item, msg)

    # and finally report it via the feedback_fn

  def _ErrorIf(self, cond, *args, **kwargs):

    """Log an error message if the passed condition is True.

    """

    cond = (bool(cond)

    if cond:

      self._Error(*args, **kwargs)

    # do not mark the operation as failed for WARN cases only

                for group in groups)

    # Fix up all parameters

      op.debug_simulate_errors = self.op.debug_simulate_errors

      op.verbose = self.op.verbose

      op.error_codes = self.op.error_codes

    """

    node = ninfo.name

    # main result, nresult should be a non-empty dict

    test = not nresult or not isinstance(nresult, dict)

    """

    node = ninfo.name

    ntime = nresult.get(constants.NV_TIME, None)

    try:

      return

    node = ninfo.name

    # checks vg existence and size > 20G

    vglist = nresult.get(constants.NV_VGLIST, None)

      return

    node = ninfo.name

    missing = nresult.get(constants.NV_BRIDGES, None)

    test = not isinstance(missing, list)

    """

    node = ninfo.name

    test = constants.NV_NODELIST not in nresult

    _ErrorIf(test, self.ENODESSH, node,

    available on the instance's node.

    """

    node_current = instanceconfig.primary_node

    node_vol_should = {}

    """

    node = ninfo.name

    if drbd_helper:

      helper_result = nresult.get(constants.NV_DRBDHELPER, None)

    """

    node = ninfo.name

    remote_os = nresult.get(constants.NV_OSLIST, None)

    test = (not isinstance(remote_os, list) or

    """

    node = ninfo.name

    assert not nimg.os_fail, "Entered _VerifyNodeOS with failed OS rpc?"

    """

    node = ninfo.name

    nimg.lvm_fail = True

    lvdata = nresult.get(constants.NV_LVLIST, "Missing LV data")

    """

    node = ninfo.name

    # try to read free memory (from the hypervisor)

    hv_info = nresult.get(constants.NV_HVINFO, None)

        list of tuples (success, payload)

    """

    node_disks = {}

    node_disks_devonly = {}

    """Verify integrity of the node group, performing various test on nodes.

    """

    feedback_fn("* Verifying group '%s'" % self.group_info.name)

    if not self.my_node_names:

      return True

    self.bad = False

    verbose = self.op.verbose

    self._feedback_fn = feedback_fn

  """Logical unit for querying nodes.

  """

  REQ_BGL = False

  def CheckArguments(self):

              for instance_name in lu.owned_locks(locking.LEVEL_INSTANCE)

              for group_uuid in lu.cfg.GetInstanceNodeGroups(instance_name))

      elif level == locking.LEVEL_NODE:

  @staticmethod

  def _CheckGroupLocks(lu):

  """Query for resources/items of a certain kind.

  """

  REQ_BGL = False

  def CheckArguments(self):

  """Query for resources/items of a certain kind.

  """

  REQ_BGL = False

  def CheckArguments(self):

    # later in the procedure; this also means that if the re-add

    # fails, we are left with a non-offlined, broken node

    if self.op.readd:

      self.LogInfo("Readding a node, the offline/drained flags were reset")

      # if we demote the node, we do cleanup later in the procedure

      new_node.master_candidate = self.master_candidate

  """Logical unit for querying instances.

  """

  REQ_BGL = False

  def CheckArguments(self):

      joinargs.append(self.op.instance_name)

      self.instance_file_storage_dir = utils.PathJoin(*joinargs)

  def CheckPrereq(self):

          self.lu.LogWarning("Can't remove old LV: %s" % msg,

                             hint="remove unused LVs manually")

    """Replace a disk on the primary or secondary for DRBD 8.

    The algorithm for replace is quite complicated:

    return ResultWithJobs(jobs)

  """Generic tags LU.

  This is an abstract class which is the parent of all the other tags LUs.

    # Wait for client to close

    try:

      try:

        # Instance of '_socketobject' has no ... member

        conn.settimeout(cls._CLIENT_CONFIRM_TIMEOUT)

        conn.recv(1)

      easy usage

  """

  # lots of instance attributes

  def __init__(self, cfg, rpc, mode, **kwargs):

  _STRING_LIST = ht.TListOf(ht.TString)

  _JOB_LIST = ht.TListOf(ht.TListOf(ht.TStrictDict(True, False, {

     # Class '...' has no 'OP_ID' member

     "OP_ID": ht.TElemOf([opcodes.OpInstanceFailover.OP_ID,

                          opcodes.OpInstanceMigrate.OP_ID,

import operator

try:

  import functools

except ImportError:

  functools = None

try:

  import roman

except ImportError:

  roman = None

# modules (hmac, for example) which have changed their behavior as well from

# one version to the other.

try:

  # Yes, we're not using the imports in this module.

  from hashlib import md5 as md5_hash

  from hashlib import sha1 as sha1_hash

  # this additional version is needed for compatibility with the hmac module

try:

  all = all

except NameError:

  all = _all

try:

  any = any

except NameError:

  any = _any

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

  """

# Even though we're using Python's built-in "partial" function if available,

# this one is always defined for testing.

  """Decorator with partial application of arguments and keywords.

  This function was copied from Python's documentation.

  def newfunc(*fargs, **fkeywords):

    newkeywords = keywords.copy()

    newkeywords.update(fkeywords)

  newfunc.func = func

  newfunc.args = args

"""

# E0203: Access to member %r before its definition, since we use

# objects.py which doesn't explicitely initialise its members

    """

    # we are actually called from init, so:

    if not isinstance(peers, list):

      raise errors.ProgrammerError("peers must be a list")

    # make a copy of peers, since we're going to shuffle the list, later

    """

    self.reader = reader

    """Process a single UDP request from a client.

    Different queries should override this function, which by defaults returns

"""

# R0904: Too many public methods

import os

        configuration errors

    """

    result = []

    seen_macs = []

    ports = {}

                                            err.errno)

    else:

      return str(err)

    logging.exception("Error while handling existing error %s", err)

    return "%s" % str(err)

  """Handler for SIGHUP.

  @param reopen_fn: List of callback functions for reopening log files

    return OpenSSL.SSL.Connection(ctx, sock)

    """Returns the ciphers string for SSL.

    """

    """

    # some parameters are unused, but this is the API

    assert self._ssl_params, "SSL not initialized"

    return (self._ssl_cert.digest("sha1") == cert.digest("sha1") and

    """

    # today we don't have per-request filtering, but we might want to

    # add it in the future

    return self.AUTH_REALM

  def AuthenticationRequired(self, req):

    """

    # Unused argument, method could be a function

    return False

  def PreHandleRequest(self, req):

    """Called for each incoming connection

    """

    (connection, client_addr) = self.socket.accept()

    self._CollectChildren(False)

        utils.ResetTempfileModule()

        self.request_executor(self, connection, client_addr)

        logging.exception("Error while handling request from %s:%s",

                          client_addr[0], client_addr[1])

        os._exit(1)

    """

    raise NotImplementedError

    """Get instance information to perform a migration.

    By default assume no information is needed.

import logging

from ganeti import constants

from ganeti import utils

from ganeti import objects

from ganeti.hypervisor import hv_base

    return self.GetLinuxNodeInfo()

  @classmethod

                         hvparams, beparams, root_dir=None):

    """Return information for connecting to the console of an instance.

import logging

from ganeti import constants

from ganeti import utils

from ganeti import objects

from ganeti.hypervisor import hv_base

import itertools

try:

  from pyinotify import pyinotify

except ImportError:

  import pyinotify

  @ivar writable: Whether the job is allowed to be modified

  """

  __slots__ = ["queue", "id", "ops", "log_serial", "ops_iter", "cur_opctx",

               "received_timestamp", "start_timestamp", "end_timestamp",

               "__weakref__", "processor_lock", "writable"]

      logging.exception("%s: Canceling job", opctx.log_prefix)

      assert op.status == constants.OP_STATUS_CANCELING

      return (constants.OP_STATUS_CANCELING, None)

      logging.exception("%s: Caught exception in %s",

                        opctx.log_prefix, opctx.summary)

      return (constants.OP_STATUS_ERROR, _EncodeOpError(err))

  """The actual job workers.

  """

    """Job executor.

    @type job: L{_QueuedJob}

    self._lock = locking.SharedLock("JobDepMgr")

  @locking.ssynchronized(_LOCK, shared=1)

    """Retrieves information about waiting jobs.

    @type requested: set

  """

  def wrapper(self, *args, **kwargs):

    assert self._queue_filelock is not None, "Queue should be open"

    return fn(self, *args, **kwargs)

  return wrapper

    try:

      data = serializer.LoadJson(raw_data)

      job = _QueuedJob.Restore(self, data, writable)

      raise errors.JobFileCorrupted(err)

    return job

"""Module implementing the Ganeti locking code."""

# W0212 since e.g. LockSet methods use (a lot) the internals of

# SharedLock

      if self._nwaiters == 0:

        self._Cleanup()

    """Close the writing side of the pipe to notify all waiters.

    """

      self._check_owned()

      self._waiters.remove(threading.currentThread())

    """Notify all currently waiting threads.

    """

    # the test cases.

    return compat.any((self._is_owned(l) for l in LEVELS[level + 1:]))

    """Check if the current thread owns the BGL.

    Both an exclusive or a shared acquisition work.

    return BGL in self.__keyring[LEVEL_CLUSTER]._list_owned()

  @staticmethod

    """Check if the level contains the BGL.

    Check if acting on the given level and set of names will change

    logging.error("LUXI request not a dict: %r", msg)

    raise ProtocolError("Invalid LUXI request (not a dict)")

  if method is None or args is None:

    logging.error("LUXI request missing method or arguments: %r", msg)

    raise ProtocolError("Invalid response from server: %r" % data)

  return (data[KEY_SUCCESS], data[KEY_RESULT],

def FormatResponse(success, result, version=None):

      old_transp = self.transport

      self.transport = None

      old_transp.Close()

      pass

  def _SendMethodCall(self, data):

    return timeout

  """Base class for OpCode execution callbacks.

  """

"""

# E0203: Access to member %r before its definition, since we use

# objects.py which doesn't explicitely initialise its members

      raise errors.ConfigurationError("Invalid object passed to FromDict:"

                                      " expected dict, got %s" % type(val))

    val_str = dict([(str(k), v) for k, v in val.iteritems()])

    return obj

  @staticmethod

    """Fill defaults for missing configuration values.

    """

    # because these are "defined" via slots, not manually

    if self.master_capable is None:

      self.master_capable = True

    """Fill defaults for missing configuration values.

    """

    # because these are "defined" via slots, not manually

    if self.hvparams is None:

      self.hvparams = constants.HVC_DEFAULTS

# this are practically structures, so disable the message about too

# few public methods:

import logging

import re

  field handling.

  """

  # as OP_ID is dynamically defined

  __metaclass__ = _AutoOpParamSlots

  @ivar priority: Opcode priority for queue

  """

  # as OP_ID is dynamically defined

  WITH_LU = True

  OP_PARAMS = [

"""

import re

import logging

import pyparsing as pyp

_SERIAL_NO_DOC = "%s object serial number, incremented on each modification"

  """Gets the contents of an unknown field.

  """

    if op != qlang.OP_OR:

      self._NeedAllNames()

    """Called when handling an unary operation.

    @type op: string

  """Converts a query filter to a callable usable for filtering.

  """

  #: How deep filters can be nested

  _LEVELS_MAX = 10

    @param operands: List of operands

    """

    try:

      (name, value) = operands

    except (ValueError, TypeError):

  return fn

  """Returns the name of a node's group.

  @type ctx: L{NodeQueryData}

  return fn

  """Get a NIC's IP address.

  @type ctx: L{InstanceQueryData}

"""

# C0103: Invalid name, since the R_* names are not conforming

  params = dict((str(key), value) for (key, value) in params.items())

  try:

    op.Validate(False)

  except (errors.OpPrereqError, TypeError), err:

    raise http.HttpBadRequest("Invalid body parameters: %s" % err)

  return _ConfigCurl

  """Ganeti RAPI client.

  """

"""

# C0103: Invalid name, since the R_* names are not conforming

"""

# C0103: Invalid name, since the R_* names are not conforming

  except KeyError:

    pass

  else:

      # Backwards compatibility for strings of the format "1, 2, 3"

      try:

        data["disks"] = [int(part) for part in raw_disks.split(",")]

    Example: ["tag1", "tag2", "tag3"]