Synnefo » snf-ganeti

#!/usr/bin/python

#

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

  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()

#!/usr/bin/python

#

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

    """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)

  # Normalize and check parameters

  if options.host is not None:

    try:

    except errors.OpPrereqError, err:

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

  """

  result = {}

  port = netutils.GetDaemonPort(constants.NODED)

  if constants.NV_HYPERVISOR 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)

                               " entries: %s" % invalid_hvs,

                               errors.ECODE_INVAL)

  if netutils.IP4Address.IsLoopback(hostname.ip):

    raise errors.OpPrereqError("This host's IP (%s) resolves to a loopback"

                               " belong to this host. Aborting." %

                               hostname.ip, errors.ECODE_ENVIRON)

  if netutils.TcpPing(clustername.ip, constants.DEFAULT_NODED_PORT,

                   timeout=5):

  @return: list of (node, votes)

  """

  try:

    node_list.remove(myself)

  except ValueError:

  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:

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

    """

    new_name = hostname.name

    self.ip = new_ip = hostname.ip

  def CheckArguments(self):

    # validate/normalize the node name

  def BuildHooksEnv(self):

    """Build hooks env.

    Any errors are signaled by raising errors.OpPrereqError.

    """

    cfg = self.cfg

    if self.op.secondary_ip is None:

      self.op.secondary_ip = primary_ip

    if not netutils.IP4Address.IsValid(self.op.secondary_ip):

    new_name = self.op.new_name

    if self.op.name_check:

      if (self.op.ip_check and

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

                                   errors.ECODE_NOTUNIQUE)

    instance_list = self.cfg.GetInstanceList()

      raise errors.OpPrereqError("Instance '%s' is already in the cluster" %

                                 new_name, errors.ECODE_EXISTS)

  def Exec(self, feedback_fn):

    """Reinstall the instance.

      self.op.start = False

    # validate/normalize the instance name

    self.op.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

    # 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" %

    # _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()

    """

    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

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

    raise errors.GenericError("HMAC is wrong")

          utils.ValidateServiceName(port),

          magic)

  return struct.unpack(_STRUCT_UCRED, peercred)

  try:

  except errors.ResolverError, err:

    raise errors.OpPrereqError("The given name (%s) does not resolve: %s" %

                               (err[0], err[2]), errors.ECODE_RESOLVER)

  """

    """Initialize the host name object.

    """

    if name is None:

  @staticmethod

    """Return the current system's name.

    This is simply a wrapper over C{socket.gethostname()}.

    return socket.gethostname()

  @staticmethod

    @type hostname: str

    @param hostname: hostname to look up

    @raise errors.ResolverError: in case of errors in resolving

    """

    try:

    except (socket.gaierror, socket.herror, socket.error), err:

      # hostname not found in DNS, or other socket exception in the

      # (code, description format)

      raise errors.ResolverError(hostname, err.args[0], err.args[1])

    """Validate and normalize the given hostname.

    @attention: the validation is a bit more relaxed than the standards

    @raise errors.OpPrereqError: when the name is not valid

    """

    hostname = hostname.lower()

        # double-dots, meaning empty label

        ".." in hostname or

        # empty initial label

def _AddressLookup(node_list,

                   ssc=ssconf.SimpleStore,

  """Return addresses for given node names.

  @type node_list: list

  @returns: List of corresponding addresses, if found

  """

  addresses = []

  return addresses

#

#

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

  """

  if ss is None:

    ss = SimpleStore()

def CheckMaster(debug, ss=None):

      L{constants.ETC_HOSTS}

  """

def RemoveEtcHostsEntry(file_name, hostname):

      L{constants.ETC_HOSTS}

  """

def TimestampForFilename():

  """

  cl = GetClient()

  readd = opts.readd

  try:

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")

#!/usr/bin/python

#

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

  def _init_cluster(self, cfg):

    """Initializes the cfg object"""

    ip = constants.IP4_ADDRESS_LOCALHOST

    cluster_config = objects.Cluster(

    self.assertEqual(gid, os.getgid())

  def testUppercase(self):

    data = "AbC.example.com"

  def testTooLongName(self):

    data = "a.b." + "c" * 255

  def testTrailingDot(self):

    data = "a.b.c"

  def testInvalidName(self):

    data = [

      "a..b",

      ]

    for value in data:

  def testValidName(self):

    data = [

      "a.b.c",

      ]

    for value in data:

class TestIPAddress(unittest.TestCase):

    node_list = ["node%d.example.com" % n for n in range(0, 255, 13)]

    ssc = GetFakeSimpleStoreClass(lambda s: [])

    node_addr_map = dict(zip(node_list, addr_list))

    result = rpc._AddressLookup(node_list, ssc=ssc, nslookup_fn=nslookup_fn)

    self.assertEqual(result, addr_list)

    node_addr_list = [ " ".join(t) for t in zip(node_list[n:], addr_list[n:])]

    ssc = GetFakeSimpleStoreClass(lambda s: node_addr_list)

    node_addr_map = dict(zip(node_list[:n], addr_list[:n]))

    result = rpc._AddressLookup(node_list, ssc=ssc, nslookup_fn=nslookup_fn)

    self.assertEqual(result, addr_list)

#

#

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

        return "test.cluster"

    def GetMasterNode(self):

    def GetDefaultIAllocator(Self):

        return "testallocator"