Synnefo » snf-ganeti

"""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,