Synnefo » snf-ganeti » ganeti-local

  """

    """

    if default_proc_fun is None:

    self.notifier = pyinotify.Notifier(watch_manager, default_proc_fun)

    # here we need to steal the file descriptor from the notifier, so we can

    # use it in the global asyncore select, and avoid calling the

    # check_events() function of the notifier (which doesn't allow us to select

  def handle_read(self):

    self.notifier.read_events()

    self.notifier.process_events()

  @raise RPCFail: if we don't find a valid OS

  """

  status, payload = _TryOSFromDisk(name_only, base_dir)

  if not status:

import sys

import textwrap

import os.path

import time

import logging

from cStringIO import StringIO

                                    default=False, action="store_true",

                                    help="Ignore errors from secondaries")

                            action="store_false", default=True,

                            help="Don't shutdown the instance (unsafe)")

and can proceed even if some udp packets are lost. It's up to the user to

reschedule queries if they haven't received responses and they need them.

  client = ConfdClient(...) # includes callback specification

  req = confd_client.ConfdClientRequest(type=constants.CONFD_REQ_PING)

  client.SendRequest(req)

confirming what you already got.

"""

import socket

import time

import random

    @param callback: function to call when getting answers

    @type port: integer

    @keyword port: confd port (default: use GetDaemonPort)

    @keyword logger: optional logger for internal conditions

    """

    @type callback: f(L{ConfdUpcallPayload})

    @param callback: function to call when getting answers

    @keyword logger: optional logger for internal conditions

    """

import asyncore

import os

import signal

import errno

import logging

class Mainloop(object):

  """Generic mainloop for daemons

  """

  def __init__(self):

    """Constructs a new Mainloop instance.

    """

    self._signal_wait = []

    self.scheduler = AsyncoreScheduler(time.time)

  @utils.SignalHandled([signal.SIGCHLD])

  @utils.SignalHandled([signal.SIGTERM])

    """Runs the mainloop.

    @type signal_handlers: dict

    @param signal_handlers: signal->L{utils.SignalHandler} passed by decorator

    running = True

    # Start actual main loop

    while running:

      if not self.scheduler.empty():

        try:

          self.scheduler.run()

  @type daemon_name: string

  @param daemon_name: daemon name

  @param optionparser: initialized optionparser with daemon-specific options

                       (common -f -d options will be handled by this module)

  @type dirs: list of strings

  @param dirs: list of directories that must exist for this daemon to work

  @type check_fn: function which accepts (options, args)

    else:

      kvm_cmd.extend(['-nographic'])

    kvm_cmd.extend(['-monitor', monitor_dev])

    if hvp[constants.HV_SERIAL_CONSOLE]:

      serial_dev = ('unix:%s,server,nowait' %

class XenHvmHypervisor(XenHypervisor):

  """Xen HVM hypervisor interface"""

  PARAMETERS = {

    constants.HV_ACPI: hv_base.NO_CHECK,

    queue, in order for it to be picked up by the queue processors.

    @type job_id: job ID

    @type ops: list

    @param ops: The list of OpCodes that will become the new job.

    @rtype: job ID

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

# 02110-1301, USA.

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

import os

  def __init__(self, lock):

    """Constructor for _BaseCondition.

    @param lock: condition base lock

    """

    self._poller = None

  def _check_unnotified(self):

    if self._notified:

      raise RuntimeError("cannot use already notified condition")

from ganeti import rpc

from ganeti import cmdlib

from ganeti import locking

class _LockAcquireTimeout(Exception):

    return baserlib.BuildUriList(rootlist, "/%s")

  """Return a list of resources underneath given id.

  This is to generalize querying of version resources lists.

  @return: a list of resources names.

  """

  rlist = []

  for handler in CONNECTOR.values():

    for idx, d in enumerate(disk_data):

      if not isinstance(d, int):

        raise http.HttpBadRequest("Disk %d specification wrong: should"

      disks.append({"size": d})

    # nic processing (one nic only)

    nics = [{"mac": fn("mac", constants.VALUE_AUTO)}]

    if fn("link", None) is not None:

      nics[0]["link"] = fn("link")

    if fn("bridge", None) is not None:

    op = opcodes.OpCreateInstance(

      mode=constants.INSTANCE_CREATE,

    self._last_inode = None

    self._last_mtime = None

    self._last_size = None

    # we need a forced reload at class init time, to initialize _last_*

    self._Load(force=True)

    mtime = cfg_stat.st_mtime

    size = cfg_stat.st_size

      self._last_inode = inode

      self._last_mtime = mtime

      self._last_size = size

      return False

    try: