Synnefo » snf-ganeti » ganeti-local

  return payload

  """Calculate the environment for an os script.

  @type instance: L{objects.Instance}

  @param instance: target instance for the os script run

  @type debug: integer

  @param debug: debug level (0 or 1, for OS Api 10)

  @rtype: dict

  """

  result = {}

  result['OS_API_VERSION'] = '%d' % api_version

  result['INSTANCE_NAME'] = instance.name

  result['INSTANCE_OS'] = instance.os

    try:

      variant = instance.os.split('+', 1)[1]

    except IndexError:

    result['OS_VARIANT'] = variant

  for idx, disk in enumerate(instance.disks):

    real_disk = _RecursiveFindBD(disk)

    fn(*args, **kwargs)

    return True

  except errors.BlockDeviceError, err:

    return False

  result = rpc.RpcRunner.call_node_stop_master(master, True)

  msg = result.fail_msg

  if msg:

  result = rpc.RpcRunner.call_node_leave_cluster(master, modify_ssh_setup)

  msg = result.fail_msg

  if msg:

                                                    False)

    abort_msg = abort_result.fail_msg

    if abort_msg:

      # Don't raise an exception here, as we stil have to try to revert the

      # disk status, even if this step failed.

    msg = result.fail_msg

    if msg:

      logging.error("Instance migration succeeded, but finalization failed:"

      raise errors.OpExecError("Could not finalize instance migration: %s" %

                               msg)

    minors = self.cfg.AllocateDRBDMinor([self.new_node

                                         for dev in self.instance.disks],

                                        self.instance.name)

    iv_names = {}

    for idx, (dev, new_minor) in enumerate(zip(self.instance.disks, minors)):

"""

import os

import random

import logging

import time

    @param node: a Node instance

    """

    self._EnsureUUID(node)

    """Remove a node from the configuration.

    """

    if node_name not in self._config_data.nodes:

      raise errors.ConfigurationError("Unknown node '%s'" % node_name)

                       debug=options.debug,

                       stderr_logging=not options.fork,

                       multithreaded=multithread)

    exec_fn(options, args)

  finally:

    utils.RemovePidFile(daemon_name)

class OpModifyNodeStorage(OpCode):

  OP_ID = "OP_NODE_MODIFY_STORAGE"

  __slots__ = OpCode.__slots__ + [

    "node_name",

    self._config_data = None

    self._inst_ips_by_link = None

    self._ip_to_inst_by_link = None

    self._mc_primary_ips = None

    self._nodes_primary_ips = None

    if debug:

      sys.stderr.write("Not master candidate, exiting.\n")

    sys.exit(constants.EXIT_NOTCANDIDATE)

        msg += ": %s" % output

      else:

        msg += ": %s (no output)" % retval.fail_reason

      return False, msg

    remotehostname = retval.stdout.strip()

import resource

import logging

import signal

from cStringIO import StringIO

  re_flags = 0

  if not case_sensitive:

    re_flags |= re.IGNORECASE

  mo = re.compile("^%s(\..*)?$" % re.escape(key), re_flags)

  names_filtered = []

  string_matches = []

  for name in name_list:

    if mo.match(name) is not None:

      names_filtered.append(name)

        string_matches.append(name)

  if len(string_matches) == 1:

    success = True

  except socket.timeout:

    success = False

    success = (not live_port_needed) and (errcode == errno.ECONNREFUSED)

  return success