Synnefo » snf-ganeti » ganeti-local

"""

import os

import sys

import logging

import time

try:

  from pyinotify import pyinotify

except ImportError:

  import pyinotify

    # no need to call the parent's constructor

    self.watch_manager = watch_manager

    self.callback = callback

    self.mask = pyinotify.EventsCodes.IN_IGNORED | \

                pyinotify.EventsCodes.IN_MODIFY

    self.file = filename

"""

import os

import sys

class ClientRequestWorker(workerpool.BaseWorker):

  def RunTask(self, server, request, client_address):

    """Process the request.

    try:

      server.finish_request(request, client_address)

      server.close_request(request)

      server.handle_error(request, client_address)

      server.close_request(request)

    self.request_workers.AddTask(self, request, client_address)

  @utils.SignalHandled([signal.SIGINT, signal.SIGTERM])

    """Handle one request at a time until told to quit."""

    assert isinstance(signal_handlers, dict) and \

           len(signal_handlers) > 0, \

  READ_SIZE = 4096

  def setup(self):

    self._buffer = ""

    self._msgs = collections.deque()

    self._ops = ClientOps(self.server)

  def __init__(self, server):

    self.server = server

    queue = self.server.context.jobqueue

    # TODO: Parameter validation

    if method == luxi.REQ_SUBMIT_JOB:

      logging.info("Received new job")

      ops = [opcodes.OpCode.LoadOpCode(state) for state in args]

  This class creates and holds common objects shared by all threads.

  """

  _instance = None

  def __init__(self):

      # Call function

      result = int(bool(fn()))

      assert result in (0, 1)

      logging.exception("Error while calling function in separate process")

      # 0 and 1 are reserved for the return value

      result = 33

  # Parent process

    confirmation = sys.stdin.readline().strip()

    if confirmation != "YES":

      sys.exit(constants.EXIT_FAILURE)

    return

"""Ganeti node daemon"""

import os

import sys

  return wrapper

  """The server implementation.

  This class holds all methods exposed over the RPC interface.

  """Main node daemon function, executed with the PID file held.

  """

  # Read SSL certificate

  if options.ssl:

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

"""

import glob

import logging

import optparse

"""

import os

import sys

import time

        self._data = {}

      else:

        self._data = serializer.Load(state_data)

      # Ignore errors while loading the file and treat it as empty

      self._data = {}

      logging.warning(("Invalid state file. Using defaults."

          try:

            logging.info("Activating disks for instance %s", instance.name)

            instance.ActivateDisks()

            logging.exception("Error while activating disks for instance %s",

                              instance.name)

                        instance.name, last)

          instance.Restart()

          self.started_instances.add(instance.name)

          logging.exception("Error while restarting instance %s",

                            instance.name)

  """Main function.

  """

  options, args = ParseOptions()

import asyncore

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.

    utils.RemoveFile(constants.HMAC_CLUSTER_KEY)

    utils.RemoveFile(constants.RAPI_CERT_FILE)

    utils.RemoveFile(constants.SSL_CERT_FILE)

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

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

      it's not required to return anything.

  """

  clist = []

  if disk.children:

    for child in disk.children:

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

import imp

import os

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

    """

    raise NotImplementedError

  def HooksCallBack(self, phase, hook_results, feedback_fn, lu_result):

    """Notify the LU about the results of its hooks.

  }

  if override:

    args.update(override)

def _AdjustCandidatePool(lu, exceptions):

    try:

      hm.RunPhase(constants.HOOKS_PHASE_POST, [master])

    except:

      self.LogWarning("Errors occurred running hooks on %s" % master)

    result = self.rpc.call_node_stop_master(master, False)

    """

    node = nodeinfo.name

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

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

    available on the instance's node.

    """

    node_current = instanceconfig.primary_node

    node_vol_should = {}

    """

    self.bad = False

    verbose = self.op.verbose

    self._feedback_fn = feedback_fn

    feedback_fn("* Verifying global settings")

    try:

      hm.RunPhase(constants.HOOKS_PHASE_POST, [node.name])

    except:

      self.LogWarning("Errors occurred running hooks on %s" % node.name)

    result = self.rpc.call_node_leave_cluster(node.name, modify_ssh_setup)

  """Logical unit for querying nodes.

  """

  _OP_REQP = ["output_fields", "names", "use_locking"]

  REQ_BGL = False

    # 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.

  """

  _OP_REQP = ["output_fields", "names", "use_locking"]

  REQ_BGL = False

  _SIMPLE_FIELDS = ["name", "os", "network_port", "hypervisor",

    """Computes the list of nodes and their attributes.

    """

    all_info = self.cfg.GetAllInstancesInfo()

    if self.wanted == locking.ALL_SET:

      # caller didn't specify instance names, so ordering is not important

      easy usage

  """

  _ALLO_KEYS = [

    "mem_size", "disks", "disk_template",

    "os", "tags", "nics", "vcpus", "hypervisor",

    """

    self.reader = reader

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

    Different queries should override this function, which by defaults returns

          raise

      ip, port = address

      self.handle_datagram(payload, ip, port)

      # we need to catch any exception here, log it, but proceed, because even

      # if we failed handling a single request, we still want to continue.

      logging.error("Unexpected exception", exc_info=True)

        else:

          raise

      self._out_queue.pop(0)

      # we need to catch any exception here, log it, but proceed, because even

      # if we failed sending a single datagram we still want to continue.

      logging.error("Unexpected exception", exc_info=True)

  code = 505

  CONTENT_TYPE = "application/json"

  def Encode(self, data):

  """HTTP client worker class.

  """

    try:

      HttpClientRequestExecutor(pend_req.request)

    finally:

    """Called for each incoming connection

    """

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

    self._CollectChildren(False)

        self.socket = None

        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.

  @ivar change: a Condition variable we use for waiting for job changes

  """

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

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

               "lock_status", "change",

  """The actual job workers.

  """

    """Job executor.

    This functions processes a job. It is closely tied to the _QueuedJob and

  """

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

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

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

  return wrapper

    try:

      job = _QueuedJob.Restore(self, data)

      new_path = self._GetArchivedJobPath(job_id)

      if filepath == new_path:

        # job already archived (future case)

      if self._nwaiters == 0:

        self._Cleanup()

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

    """

      assert self._nwaiters > 0

      self._nwaiters -= 1

    """Notify all currently waiting threads.

    """

    self._cond = threading.Condition(lock=lock)

    self._nwaiters = 0

    """Notifies the condition.

    """

      old_transp = self.transport

      self.transport = None

      old_transp.Close()

      pass

  def CallMethod(self, method, args):

    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

import ConfigParser

import re

      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

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

RAPI_ACCESS_WRITE = "write"

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

    """

    return baserlib._Tags_GET(self.TAG_LEVEL, name=self.name)

  def PUT(self):

    you'll have back a job id.

    """

    if 'tag' not in self.queryargs:

      raise http.HttpBadRequest("Please specify tag(s) to add using the"

                                " the 'tag' parameter")

    /tags?tag=[tag]&tag=[tag]

    """

    if 'tag' not in self.queryargs:

      # no we not gonna delete all tags

      raise http.HttpBadRequest("Cannot delete all tags - please specify"

      args = (msg, prereq)

    else:

      args = (msg, )

class Client:

"""

import logging

    """

    raise NotImplementedError()

    """Modifies an entity within the storage unit.

    @type name: string

    raise NotImplementedError()

  """File storage unit.

  """

    return values

  """Base class for LVM storage containers.

  @cvar LIST_FIELDS: list of tuples consisting of three elements: SF_*

        if callable(mapper):

          # we got a function, call it with all the declared fields

        elif len(values) == 1:

          # we don't have a function, but we had a single field

          # declared, pass it unchanged

      yield fields

  """LVM Physical Volume storage unit.

  """

  return None

  "Returns True if pred(x) is True for every element in the iterable"

  for _ in itertools.ifilterfalse(pred, seq):

    return False

  return True

  "Returns True if pred(x) is True for at least one element in the iterable"

  for _ in itertools.ifilter(pred, seq):

    return True

  @return: the value zero

  """

  UMASK = 077

  WORKDIR = "/"

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

  try:

    RemoveFile(pidfilename)

    pass

      logging.debug(*args, **kwargs)

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

    assert hasattr(self, '_lock')

    lock = self._lock

    _LockDebug("Waiting for %s", lock)

  while True:

    try:

      return fn(*args)

    except RetryAgain:

      pass

  Users of a worker pool must override RunTask in a subclass.

  """

  def __init__(self, pool, worker_id):

    """Constructor for BaseWorker thread.

          self.RunTask(*self._current_task)

          logging.debug("Worker %s: done with task %r",

                        self.worker_id, self._current_task)

          logging.error("Worker %s: Caught unhandled exception",

                        self.worker_id, exc_info=True)

      finally:

    """

    for worker in self._workers + self._termworkers:

        return True

    return False

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

# W0401: Wildcard import ganeti.cli

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

import sys

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

# W0401: Wildcard import ganeti.cli

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

import sys

import os.path

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

# W0401: Wildcard import ganeti.cli

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

import sys

import simplejson

    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

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

# W0401: Wildcard import ganeti.cli

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

import sys

import os

  @raise errors.OpPrereqError: for invalid input parameters

  """

  if client is None:

    client = GetClient()

  if mode == _SHUTDOWN_CLUSTER:

  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

    finally:

      ToStderr("Can't run console command %s with arguments:\n'%s'",

               cmd[0], " ".join(cmd))

def _FormatLogicalID(dev_type, logical_id):

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

# W0401: Wildcard import ganeti.cli

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

import sys

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

# W0401: Wildcard import ganeti.cli

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

import sys

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

# W0401: Wildcard import ganeti.cli

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

import sys

class SimpleOpener(urllib.FancyURLopener):

  """A simple url opener"""

    """No-interaction version of prompt_user_passwd."""

    return None, None

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

    val = fn(self, *args, **kwargs)

    for instance in self.instances:

    return val

  return wrapper

        Log("Idempotent %s succeeded after %d retries" %

            (msg, MAX_RETRIES - retry_count))

      return val

      if retry_count == 0:

        Log("Non-idempotent %s failed, aborting" % (msg, ))

        raise

      Log("waiting for job %s for %s" % (jid, iname), indent=2)

      try:

        results.append(cli.PollJob(jid, cl=self.cl, feedback_fn=self.Feedback))

        Log("Job for %s failed: %s" % (iname, err))

    if len(results) != len(jobs):

      raise BurninFailure()

                                    disks=[i for i in range(self.disk_count)])

        Log("run %s" % mode, indent=2)

        ops.append(op)

  @_DoBatch(True)

  def BurnReplaceDisks2(self):

                                      ignore_secondaries=False)

        Log("reboot with type '%s'" % reboot_type, indent=2)

        ops.append(op)

  @_DoCheckInstances

  @_DoBatch(True)

      if not self.opts.keep_instances:

        try:

          self.BurnRemove()

          if has_err: # already detected errors, so errors in removal

                      # are quite expected

            Log("Note: error detected during instance remove: %s" % str(err))

      arg = None

    try:

      self.cfg = config.ConfigWriter(cfg_file=arg, offline=True)

      self.path = []

    except errors.ConfigurationError, err:

      print "Error: %s" % str(err)

    if self.cfg.VerifyConfig():

      print "Config data does not validate, refusing to save."

      return False

  def do_rm(self, line):

    """Removes an instance or a node.

    """

    pointer = self.parents[-1]

    if pointer not in (data.instances, data.nodes):

      print "Can only delete instances and nodes"

      return False

  """Main program.

  """

  program = os.path.basename(sys.argv[0])

  Returns:

    (options, args), as returned by OptionParser.parse_args

  """

  parser = optparse.OptionParser(usage="\n%s" % USAGE,

                                 version="%%prog (ganeti) %s" %