Synnefo » snf-ganeti

	lib/locking.py \

	lib/luxi.py \

	lib/mcpu.py \

	lib/objects.py \

	lib/opcodes.py \

	lib/rpc.py \

	test/ganeti.luxi_unittest.py \

	test/ganeti.masterd.instance_unittest.py \

	test/ganeti.mcpu_unittest.py \

	test/ganeti.objects_unittest.py \

	test/ganeti.opcodes_unittest.py \

	test/ganeti.rapi.client_unittest.py \

from ganeti import workerpool

from ganeti import rpc

from ganeti import bootstrap

CLIENT_REQUEST_WORKERS = 16

  other node to be up too to confirm our status.

  """

  #temp instantiation of a config writer, used only to get the node list

  cfg = config.ConfigWriter()

  node_list = cfg.GetNodeList()

from ganeti import utils

from ganeti import storage

from ganeti import serializer

import ganeti.http.server # pylint: disable-msg=W0611

    """Do a TcpPing on the remote node.

    """

  @staticmethod

  def perspective_node_has_ip_address(params):

    """Checks if a node has the given ip address.

    """

  @staticmethod

  def perspective_node_info(params):

from ganeti import hypervisor

from ganeti import rapi

from ganeti.confd import client as confd_client

import ganeti.rapi.client # pylint: disable-msg=W0611

    """Check node status versus cluster desired state.

    """

    req = confd_client.ConfdClientRequest(type=

                                          constants.CONFD_REQ_NODE_ROLE_BYNAME,

                                          query=my_name)

  def __init__(self, opts, notepad):

    self.notepad = notepad

    master = client.QueryConfigValues(["master_node"])[0]

      raise NotMasterError("This is not the master node")

    # first archive old jobs

    self.ArchiveJobs(opts.job_age)

from ganeti import objects

from ganeti import locking

from ganeti import impexpd

#: How many lines to keep in the status file

  # Normalize and check parameters

  if options.host is not None:

    try:

    except errors.OpPrereqError, err:

      parser.error("Invalid hostname '%s': %s" % (options.host, err))

from ganeti import objects

from ganeti import ssconf

from ganeti import serializer

_BOOT_ID_PATH = "/proc/sys/kernel/random/boot_id"

  master_netdev, master_ip, _ = GetMasterInfo()

  err_msgs = []

      # we already have the ip:

      logging.debug("Master IP already configured, doing nothing")

    else:

  """

  result = {}

  if constants.NV_HYPERVISOR in what:

    result[constants.NV_HYPERVISOR] = tmp = {}

    else:

      for name, pip, sip in what[constants.NV_NODENETTEST]:

        fail = []

          fail.append("primary")

        if sip != pip:

            fail.append("secondary")

        if fail:

          tmp[name] = ("failure using the %s interface(s)" %

      source = constants.IP4_ADDRESS_LOCALHOST

    else:

      source = None

                                                  source=source)

  if constants.NV_LVLIST in what:

  """

  (key_pem, cert_pem) = \

                                     min(validity, _MAX_SSL_CERT_VALIDITY))

  cert_dir = tempfile.mkdtemp(dir=cryptodir,

  """

  # set the correct physical ID

  for cf in disks:

    cf.SetPhysicalID(my_name, nodes_ip)

from ganeti import constants

from ganeti import objects

from ganeti import compat

# Size of reads in _CanReadDevice

    # about its peer.

    cls._SetMinorSyncSpeed(minor, constants.SYNC_SPEED)

        _ThrowError("drbd%d: can't connect ip %s to ip %s" %

                    (minor, lhost, rhost))

      family = "ipv6"

        _ThrowError("drbd%d: can't connect ip %s to ip %s" %

                    (minor, lhost, rhost))

      family = "ipv4"

from ganeti import serializer

from ganeti import hypervisor

from ganeti import bdev

def _InitSSHSetup():

                               " entries: %s" % invalid_hvs,

                               errors.ECODE_INVAL)

  if hostname.ip.startswith("127."):

    raise errors.OpPrereqError("This host's IP resolves to the private"

                               (hostname.ip, constants.ETC_HOSTS),

                               errors.ECODE_ENVIRON)

    raise errors.OpPrereqError("Inconsistency: this host's name resolves"

                               " to %s,\nbut this ip address does not"

                               " belong to this host. Aborting." %

                               hostname.ip, errors.ECODE_ENVIRON)

                   timeout=5):

    raise errors.OpPrereqError("Cluster IP already active. Aborting.",

                               errors.ECODE_NOTUNIQUE)

  if secondary_ip:

      raise errors.OpPrereqError("Invalid secondary ip given",

                                 errors.ECODE_INVAL)

    if (secondary_ip != hostname.ip and

      raise errors.OpPrereqError("You gave %s as secondary IP,"

                                 " but it does not belong to this host." %

                                 secondary_ip, errors.ECODE_ENVIRON)

  total_timeout = 30

  # Here we have a phase where no master should be running

  def _check_ip():

      raise utils.RetryAgain()

  try:

  @return: list of (node, votes)

  """

  try:

    node_list.remove(myself)

  except ValueError:

from ganeti import rpc

from ganeti import ssh

from ganeti import compat

from optparse import (OptionParser, TitledHelpFormatter,

                      Option, OptionValueError)

  elif isinstance(err, errors.HooksFailure):

    obuf.write("Failure: hooks general failure: %s" % msg)

  elif isinstance(err, errors.ResolverError):

    if err.args[0] == this_host:

      msg = "Failure: can't resolve my own hostname ('%s')"

    else:

from ganeti import uidpool

from ganeti import compat

from ganeti import masterd

import ganeti.masterd.instance # pylint: disable-msg=W0611

    """Verify that the passed name is a valid one.

    """

    new_name = hostname.name

    self.ip = new_ip = hostname.ip

                                 " cluster has changed",

                                 errors.ECODE_INVAL)

    if new_ip != old_ip:

        raise errors.OpPrereqError("The given cluster IP address (%s) is"

                                   " reachable on the network. Aborting." %

                                   new_ip, errors.ECODE_NOTUNIQUE)

  def CheckArguments(self):

    # validate/normalize the node name

  def BuildHooksEnv(self):

    """Build hooks env.

    node_name = self.op.node_name

    cfg = self.cfg

    node = dns_data.name

    primary_ip = self.op.primary_ip = dns_data.ip

    if self.op.secondary_ip is None:

      self.op.secondary_ip = primary_ip

      raise errors.OpPrereqError("Invalid secondary IP given",

                                 errors.ECODE_INVAL)

    secondary_ip = self.op.secondary_ip

                                   errors.ECODE_INVAL)

    # checks reachability

      raise errors.OpPrereqError("Node not reachable by ping",

                                 errors.ECODE_ENVIRON)

    if not newbie_singlehomed:

      # check reachability from my secondary ip to newbie's secondary ip

                           source=myself.secondary_ip):

        raise errors.OpPrereqError("Node secondary ip not reachable by TCP"

                                   " based ping to noded port",

    # new name verification

    if self.op.check_name:

      self.op.new_name = name_info.name

    new_name = self.op.new_name

                                 new_name, errors.ECODE_EXISTS)

    if not self.op.ignore_ip:

        raise errors.OpPrereqError("IP %s of instance %s already in use" %

                                   (name_info.ip, new_name),

                                   errors.ECODE_NOTUNIQUE)

      self.LogInfo("No-installation mode selected, disabling startup")

      self.op.start = False

    # validate/normalize the instance name

    if self.op.ip_check and not self.op.name_check:

      # TODO: make the ip check more flexible and not depend on the name check

      raise errors.OpPrereqError("Cannot do ip checks without a name check",

    # instance name verification

    if self.op.name_check:

      self.op.instance_name = self.hostname1.name

      # used in CheckPrereq for ip ping check

      self.check_ip = self.hostname1.ip

        raise errors.OpPrereqError("Missing source instance name",

                                   errors.ECODE_INVAL)

    else:

      raise errors.OpPrereqError("Invalid instance creation mode %r" %

                                     errors.ECODE_INVAL)

        nic_ip = self.hostname1.ip

      else:

          raise errors.OpPrereqError("Given IP address '%s' doesn't look"

                                     " like a valid IP" % ip,

                                     errors.ECODE_INVAL)

    # ip ping checks (we use the same ip that was resolved in ExpandNames)

    if self.op.ip_check:

        raise errors.OpPrereqError("IP %s of instance %s already in use" %

                                   (self.check_ip, self.op.instance_name),

                                   errors.ECODE_NOTUNIQUE)

        if nic_ip.lower() == constants.VALUE_NONE:

          nic_dict['ip'] = None

        else:

            raise errors.OpPrereqError("Invalid IP address '%s'" % nic_ip,

                                       errors.ECODE_INVAL)

from ganeti import confd

from ganeti import ssconf

from ganeti import compat

class ConfdAsyncUDPClient(daemon.AsyncUDPSocket):

    self._requests = {}

    if self._confd_port is None:

  def UpdatePeerList(self, peers):

    """Update the list of peers

from ganeti import objects

from ganeti import serializer

from ganeti import uidpool

_config_lock = locking.SharedLock()

    # _DistributeConfig, we compute it here once and reuse it; it's

    # better to raise an error before starting to modify the config

    # file than after it was modified

    self._last_cluster_serial = -1

    self._OpenConfig()

from ganeti import utils

from ganeti import constants

from ganeti import errors

_DEFAULT_RUN_USER = "root"

      if self.family == socket.AF_UNIX:

        # override the client address, as for unix sockets nothing meaningful

        # is passed in from accept anyway

      logging.info("Accepted connection from %s",

                   FormatAddress(self.family, client_address))

      self.handle_connection(connected_socket, client_address)

  if daemon_name in constants.DAEMONS_PORTS:

    default_bind_address = constants.IP4_ADDRESS_ANY

    # For networked daemons we allow choosing the port and bind address

    optionparser.add_option("-p", "--port", dest="port",

from ganeti import uidpool

from ganeti import ssconf

from ganeti.hypervisor import hv_base

class KVMHypervisor(hv_base.BaseHypervisor):

    constants.HV_ACPI: hv_base.NO_CHECK,

    constants.HV_SERIAL_CONSOLE: hv_base.NO_CHECK,

    constants.HV_VNC_BIND_ADDRESS:

       "the VNC bind address must be either a valid IP address or an absolute"

       " pathname", None, None),

    constants.HV_VNC_TLS: hv_base.NO_CHECK,

    vnc_bind_address = hvp[constants.HV_VNC_BIND_ADDRESS]

    if vnc_bind_address:

        if instance.network_port > constants.VNC_BASE_PORT:

          display = instance.network_port - constants.VNC_BASE_PORT

          if vnc_bind_address == constants.IP4_ADDRESS_ANY:

    if not alive:

      raise errors.HypervisorError("Instance not running, cannot migrate")

      raise errors.HypervisorError("Remote host %s not listening on port"

                                   " %s, cannot migrate" % (target, port))

from ganeti import errors

from ganeti import utils

from ganeti.hypervisor import hv_base

class XenHypervisor(hv_base.BaseHypervisor):

    port = instance.hvparams[constants.HV_MIGRATION_PORT]

      raise errors.HypervisorError("Remote host %s not listening on port"

                                   " %s, cannot migrate" % (target, port))

      hv_base.ParamInSet(True, constants.HT_HVM_VALID_NIC_TYPES),

    constants.HV_PAE: hv_base.NO_CHECK,

    constants.HV_VNC_BIND_ADDRESS:

       "VNC bind address is not a valid IP address", None, None),

    constants.HV_KERNEL_PATH: hv_base.REQ_FILE_CHECK,

    constants.HV_DEVICE_MODEL: hv_base.REQ_FILE_CHECK,

from ganeti import utils

from ganeti import jstore

from ganeti import rpc

JOBQUEUE_THREADS = 25

    """

    self.context = context

    self._memcache = weakref.WeakValueDictionary()

    # The Big JobQueue lock. If a code block or method acquires it in shared

    # mode safe it must guarantee concurrency with all the code acquiring it in

from ganeti import compat

from ganeti import utils

from ganeti import objects

class _ImportExportError(Exception):

  if not utils.VerifySha1Hmac(cds, msg, hmac_digest, salt=hmac_salt):

    raise errors.GenericError("HMAC is wrong")

          utils.ValidateServiceName(port),

          magic)

from ganeti import serializer

from ganeti import constants

from ganeti import errors

# pylint has a bug here, doesn't see this import

import ganeti.http.client  # pylint: disable-msg=W0611

    """

    self._cfg = cfg

  def _InstDict(self, instance, hvp=None, bep=None, osp=None):

    """Convert the given instance to a dict.

    """

    body = serializer.DumpJson(args, indent=False)

    c.ConnectList(node_list, address_list=address_list,

                  read_timeout=read_timeout)

    return c.GetResults()

    """

    body = serializer.DumpJson(args, indent=False)

    c.ConnectNode(node, read_timeout=read_timeout)

    return c.GetResults()[node]

from ganeti import utils

from ganeti import serializer

from ganeti import objects

SSCONF_LOCK_TIMEOUT = 10

  """

  if ss is None:

    ss = SimpleStore()

def CheckMaster(debug, ss=None):

import calendar

import hmac

import collections

from cStringIO import StringIO

from ganeti import errors

from ganeti import constants

from ganeti import compat

_locksheld = []

_VALID_SERVICE_NAME_RE = re.compile("^[-_.a-zA-Z0-9]{1,128}$")

# Certificate verification results

(CERT_WARNING,

 CERT_ERROR) = range(1, 3)

  return rr

def RemoveFile(filename):

  """Remove a file ignoring some errors.

  return None

def ValidateServiceName(name):

  """Validate the given service name.

  return name

def ListVolumeGroups():

  """List volume groups and their size

  return nv

def IsValidShellParam(word):

  """Verifies is the given word is safe from the shell's p.o.v.

      L{constants.ETC_HOSTS}

  """

  SetEtcHostsEntry(constants.ETC_HOSTS, hi.ip, hi.name, [hi.ShortName()])

      L{constants.ETC_HOSTS}

  """

  RemoveEtcHostsEntry(constants.ETC_HOSTS, hi.name)

  RemoveEtcHostsEntry(constants.ETC_HOSTS, hi.ShortName())

  return ' '.join([ShellQuote(i) for i in args])

def ListVisibleFiles(path):

  """Returns a list of visible files in a directory.

  return float(seconds) + (float(microseconds) * 0.000001)

class LogFileHandler(logging.FileHandler):

  """Log handler that doesn't fallback to stderr.

from ganeti import compat

from ganeti import utils

from ganeti import errors

_SHUTDOWN_CLUSTER = "cluster"

        vnc_console_port = "%s:%s (display %s)" % (instance["pnode"],

                                                   port,

                                                   display)

        vnc_console_port = ("%s:%s (node %s) (display %s)" %

                             (vnc_bind_address, port,

                              instance["pnode"], display))

from ganeti import compat

from ganeti import errors

from ganeti import bootstrap

#: default list of field for L{ListNodes}

  """

  cl = GetClient()

  node = dns_data.name

  readd = opts.readd

from ganeti import utils

from ganeti import constants

from ganeti import backend

import testutils

class TestNodeVerify(testutils.GanetiTestCase):

  def testMasterIPLocalhost(self):

    # this a real functional test, but requires localhost to be reachable

    result = backend.VerifyNode({constants.NV_MASTERIP: local_data}, None)

    self.failUnless(constants.NV_MASTERIP in result,

                    "Master IP data not returned")

    # RFC 5735

    bad_data =  ("master.example.com", "192.0.2.1")