Synnefo » snf-ganeti » ganeti-local

    master_netdev = cfg.GetMasterNetdev()

    master_ip = cfg.GetMasterIP()

    master_node = cfg.GetMasterNode()

    logging.exception("Cluster configuration incomplete")

    return (None, None, None)

  return (master_netdev, master_ip, master_node)

    try:

      names = hypervisor.GetHypervisor(hname).ListInstances()

      results.extend(names)

      logging.exception("Error enumerating instances for hypevisor %s", hname)

      raise

  # test every 10secs for 2min

  time.sleep(1)

    if instance.name not in GetInstanceList([hv_name]):

      break

    time.sleep(10)

        # but we don't have the owner here - maybe parse from existing

        # cache? for now, we only lose lvm data when we rename, which

        # is less critical than DRBD or MD

      logging.exception("Can't rename device '%s' to '%s'", dev, unique_id)

      result = False

  return result

      # deletes dir only if empty, otherwise we want to return False

      try:

        os.rmdir(file_storage_dir)

        logging.exception("Cannot remove file storage directory '%s'",

                          file_storage_dir)

        result = False,

      if os.path.isdir(old_file_storage_dir):

        try:

          os.rename(old_file_storage_dir, new_file_storage_dir)

          logging.exception("Cannot rename '%s' to '%s'",

                            old_file_storage_dir, new_file_storage_dir)

          result =  False,

    dir_name = "%s/%s" % (self._BASE_DIR, subdir)

    try:

      dir_contents = utils.ListVisibleFiles(dir_name)

      # FIXME: must log output in case of failures

      return rr

    fdata = "%s %s %s\n" % (str(owner), state, iv_name)

    try:

      utils.WriteFile(fpath, data=fdata)

      logging.exception("Can't update bdev cache for %s", dev_path)

  @classmethod

    fpath = cls._ConvertPath(dev_path)

    try:

      utils.RemoveFile(fpath)

      logging.exception("Can't update bdev cache for %s", dev_path)

import os

import os.path

import time

import re

import platform

import logging

import copy

from ganeti import ssh

from ganeti import utils

from ganeti import locking

from ganeti import constants

from ganeti import objects

from ganeti import serializer

from ganeti import ssconf

def _BuildInstanceHookEnv(name, primary_node, secondary_nodes, os_type, status,

                          memory, vcpus, nics, disk_template, disks,

  """Builds instance related env variables for hooks

  This builds the hook environment from individual variables.

  @param bep: the backend parameters for the instance

  @type hvp: dict

  @param hvp: the hypervisor parameters for the instance

  @rtype: dict

  @return: the hook environment for this instance

    "INSTANCE_MEMORY": memory,

    "INSTANCE_VCPUS": vcpus,

    "INSTANCE_DISK_TEMPLATE": disk_template,

  }

  if nics:

    node_lvs = self.rpc.call_volume_list(nodes, vg_name)

    for node in nodes:

      # node_volume

      lvs = node_lvs[node]

      "master": cluster.master_node,

      "default_hypervisor": cluster.default_hypervisor,

      "enabled_hypervisors": cluster.enabled_hypervisors,

      "beparams": cluster.beparams,

      "candidate_pool_size": cluster.candidate_pool_size,

      "default_bridge": cluster.default_bridge,

  """Start the disks of an instance.

  """

                                           ignore_secondaries=force)

  if not disks_ok:

    _ShutdownInstanceDisks(lu, instance)

      logging.info("Starting instance %s on node %s",

                   instance.name, target_node)

                                               ignore_secondaries=True)

      if not disks_ok:

        _ShutdownInstanceDisks(self, instance)

    logging.debug("Allocated minors %s" % (minors,))

    self.proc.LogStep(4, steps_total, "changing drbd configuration")

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

      info("activating a new drbd on %s for disk/%d" % (new_node, idx))

      # create new devices on new_node; note that we create two IDs:

      # one without port, so the drbd will be activated without

    This only checks the instance list against the existing names.

    """

    # checking the new params on the primary/secondary nodes

    """

    if call_fn is None:

      call_fn = self.lu.rpc.call_iallocator_runner

    result = call_fn(self.lu.cfg.GetMasterNode(), name, self.in_text)

    result.Raise()

    def _AppendUsedPorts(instance_name, disk, used):

      duplicates = []

      if disk.dev_type == constants.LD_DRBD8 and len(disk.logical_id) >= 5:

          assert node in used, ("Node '%s' of instance '%s' not found"

                                " in node list" % (node, instance_name))

          if port in used[node]:

  # TODO: event_poll/event_check/override

  if op in (SOCKOP_SEND, SOCKOP_HANDSHAKE):

    event_poll = select.POLLOUT

  elif op == SOCKOP_RECV:

    event_poll = select.POLLIN

  elif op == SOCKOP_SHUTDOWN:

    event_poll = None

    # The timeout is only used when OpenSSL requests polling for a condition.

    # It is not advisable to have no timeout for shutdown.

"""

import logging

import re

import base64

import binascii

from ganeti import utils

from ganeti import http

"""

import os

import select

import socket

import errno

import threading

from ganeti import workerpool

from ganeti import http

import time

import signal

from ganeti import http

          # As soon as too many children run, we'll not respond to new

          # requests. The real solution would be to add a timeout for children

          # and killing them after some time.

        except os.error:

          pid = None

        if pid and pid in self._children:

import os

import os.path

from ganeti import utils

from ganeti import constants

    @return: list of (name, id, memory, vcpus, state, time spent)

    """

      result = utils.RunCmd(["xm", "list"])

      if not result.failed:

        break

"""Module implementing the job queue handling."""

import os

import errno

from ganeti import constants

from ganeti import errors

      old_transp = self.transport

      self.transport = None

      old_transp.Close()

      pass

  def CallMethod(self, method, args):

    phase = constants.HOOKS_PHASE_POST

    hpath = constants.HOOKS_NAME_CFGUPDATE

    nodes = [self.lu.cfg.GetMasterNode()]

    """Checks that this disk is correctly configured.

    """

    if self.mode not in constants.DISK_ACCESS_SET:

class Instance(TaggableObject):

import logging

from ganeti import luxi

from ganeti import rapi

from ganeti import http

        val = 0

    try:

      val = int(val)

      raise http.HttpBadRequest("Invalid value for the"

                                " '%s' parameter" % (name,))

    return val

# R0904: Too many public methods

import os

import logging

import zlib

import base64

"""

import os

import time

import subprocess

_locksheld = []

_re_shell_unquoted = re.compile('^[-.,=:/_+@A-Za-z0-9]+$')

debug_locks = False

#: when set to True, L{RunCmd} is disabled

  """

  try:

    nv = fn(val)

    nv = val

  return nv

  if source is not None:

    try:

      sock.bind((source, 0))

      if errcode == errno.EADDRNOTAVAIL:

        success = False

def all(seq, pred=bool):

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

    return False

  return True

def any(seq, pred=bool):

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

    return True

  return False

  @param name: the daemon name used to derive the pidfile name

  """

  pidfilename = DaemonPidFileName(name)

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

  try: