/ - Diff - snf-ganeti - Greek Research and Technology Network's projects

     import os
     import sys
     import socket
     from optparse import OptionParser
-...
       """
       options, args = ParseOptions()
       debug = options.debug
       try:
         myself = utils.HostInfo()
       except errors.ResolverError, err:
         sys.stderr.write("Cannot resolve my own name (%s)\n" % err.args[0])
         return EXIT_NODESETUP_ERROR
       result = CheckNodeSetup(debug)
       if not result:
         if debug:
-...
         return EXIT_NODESETUP_ERROR
       master_node, master_netdev, master_ip = result
       if socket.gethostname() != master_node and args[0] == "start":
       if myself.name != master_node and args[0] == "start":
         if debug:
           sys.stderr.write("Not master, ignoring request.\n")
         return EXIT_NOTMASTER

     import time
     import fcntl
     import errno
     import socket
     from optparse import OptionParser
     from ganeti import utils
     from ganeti import constants
     from ganeti import ssconf
     from ganeti import errors
     class Error(Exception):
-...
       def __init__(self):
         sstore = ssconf.SimpleStore()
         master = sstore.GetMasterNode()
         if master != socket.gethostname():
         if master != utils.HostInfo().name:
           raise NotMasterError("This is not the master node")
         self.instances = InstanceList()
         self.messages = []
-...
         if options.debug:
           sys.stderr.write("Not master, exiting.\n")
         sys.exit(constants.EXIT_NOTMASTER)
       except errors.ResolverError, err:
         sys.stderr.write("Cannot resolve hostname '%s', exiting.\n" % err.args[0])
         sys.exit(constants.EXIT_NODESETUP_ERROR)
       except Error, err:
         print err

         except errors.HooksFailure, err:
           logger.ToStderr("Failure: hooks general failure: %s" % str(err))
           result = 1
         except errors.ResolverError, err:
           this_host = utils.HostInfo.SysName()
           if err.args[0] == this_host:
             msg = "Failure: can't resolve my own hostname ('%s')"
           else:
             msg = "Failure: can't resolve hostname '%s'"
           logger.ToStderr(msg % err.args[0])
           result = 1
         except errors.OpPrereqError, err:
           logger.ToStderr("Failure: prerequisites not met for this"
                           " operation:\n%s" % str(err))

                                        " use 'gnt-cluster init' first.")
           if self.REQ_MASTER:
             master = sstore.GetMasterNode()
             if master != socket.gethostname():
             if master != utils.HostInfo().name:
               raise errors.OpPrereqError("Commands must be run on the master"
                                          " node %s" % master)
-...
         if config.ConfigWriter.IsCluster():
           raise errors.OpPrereqError("Cluster is already initialised")
         hostname_local = socket.gethostname()
         self.hostname = hostname = utils.LookupHostname(hostname_local)
         if not hostname:
           raise errors.OpPrereqError("Cannot resolve my own hostname ('%s')" %
                                      hostname_local)
         if hostname.name != hostname_local:
           raise errors.OpPrereqError("My own hostname (%s) does not match the"
                                      " resolver (%s): probably not using FQDN"
                                      " for hostname." %
                                      (hostname_local, hostname.name))
         self.hostname = hostname = utils.HostInfo()
         if hostname.ip.startswith("127."):
           raise errors.OpPrereqError("This host's IP resolves to the private"
                                      " range (%s). Please fix DNS or /etc/hosts." %
                                      (hostname.ip,))
         self.clustername = clustername = utils.LookupHostname(self.op.cluster_name)
         if not clustername:
           raise errors.OpPrereqError("Cannot resolve given cluster name ('%s')"
                                      % self.op.cluster_name)
         self.clustername = clustername = utils.HostInfo(self.op.cluster_name)
         result = utils.RunCmd(["fping", "-S127.0.0.1", "-q", hostname.ip])
         if result.failed:
-...
         """Verify that the passed name is a valid one.
         """
         hostname = utils.LookupHostname(self.op.name)
         if not hostname:
           raise errors.OpPrereqError("Cannot resolve the new cluster name ('%s')" %
                                      self.op.name)
         hostname = utils.HostInfo(self.op.name)
         new_name = hostname.name
         self.ip = new_ip = hostname.ip
-...
         node_name = self.op.node_name
         cfg = self.cfg
         dns_data = utils.LookupHostname(node_name)
         if not dns_data:
           raise errors.OpPrereqError("Node %s is not resolvable" % node_name)
         dns_data = utils.HostInfo(node_name)
         node = dns_data.name
         primary_ip = self.op.primary_ip = dns_data.ip
-...
         This checks that we are not already the master.
         """
         self.new_master = socket.gethostname()
         self.new_master = utils.HostInfo().name
         self.old_master = self.sstore.GetMasterNode()
         if self.old_master == self.new_master:
-...
         """
         filename = self.op.filename
         myname = socket.gethostname()
         myname = utils.HostInfo().name
         for node in self.nodes:
           if node == myname:
-...
         self.instance = instance
         # new name verification
         hostname1 = utils.LookupHostname(self.op.new_name)
         if not hostname1:
           raise errors.OpPrereqError("New instance name '%s' not found in dns" %
                                      self.op.new_name)
         name_info = utils.HostInfo(self.op.new_name)
         self.op.new_name = new_name = hostname1.name
         self.op.new_name = new_name = name_info.name
         if not getattr(self.op, "ignore_ip", False):
           command = ["fping", "-q", hostname1.ip]
           command = ["fping", "-q", name_info.ip]
           result = utils.RunCmd(command)
           if not result.failed:
             raise errors.OpPrereqError("IP %s of instance %s already in use" %
                                        (hostname1.ip, new_name))
                                        (name_info.ip, new_name))
       def Exec(self, feedback_fn):
-...
                                      " primary node"  % self.op.os_type)
         # instance verification
         hostname1 = utils.LookupHostname(self.op.instance_name)
         if not hostname1:
           raise errors.OpPrereqError("Instance name '%s' not found in dns" %
                                      self.op.instance_name)
         hostname1 = utils.HostInfo(self.op.instance_name)
         self.op.instance_name = instance_name = hostname1.name
         instance_list = self.cfg.GetInstanceList()

     """
     import os
     import socket
     import tempfile
     import random
-...
         else:
           self._cfg_file = cfg_file
         self._temporary_ids = set()
         # Note: in order to prevent errors when resolving our name in
         # _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._my_hostname = utils.HostInfo().name
       # this method needs to be static, so that we can call it on the class
       @staticmethod
-...
           return True
         bad = False
         nodelist = self.GetNodeList()
         myhostname = socket.gethostname()
         myhostname = self._my_hostname
         tgt_list = []
         for node in nodelist:

       """
     class ResolverError(GenericError):
       """Host name cannot be resolved.
       This is not a normal situation for Ganeti, as we rely on having a
       working resolver.
       The non-resolvable hostname is available as the first element of the
       args tuple; the other two elements of the tuple are the first two
       args of the socket.gaierror exception (error code and description).
       """
     class HooksFailure(GenericError):
       """A generic hook failure.

     class HostInfo:
       """Class holding host info as returned by gethostbyname
       """Class implementing resolver and hostname functionality
       """
       def __init__(self, name, aliases, ipaddrs):
       def __init__(self, name=None):
         """Initialize the host name object.
         Arguments are the same as returned by socket.gethostbyname_ex()
         If the name argument is not passed, it will use this system's
         name.
         """
         self.name = name
         self.aliases = aliases
         self.ipaddrs = ipaddrs
         if name is None:
           name = self.SysName()
         self.query = name
         self.name, self.aliases, self.ipaddrs = self.LookupHostname(name)
         self.ip = self.ipaddrs[0]
       @staticmethod
       def SysName():
         """Return the current system's name.
     def LookupHostname(hostname):
       """Look up hostname
         This is simply a wrapper over socket.gethostname()
       Args:
         hostname: hostname to look up, can be also be a non FQDN
         """
         return socket.gethostname()
       Returns:
         a HostInfo object
       @staticmethod
       def LookupHostname(hostname):
         """Look up hostname
       """
       try:
         (name, aliases, ipaddrs) = socket.gethostbyname_ex(hostname)
       except socket.gaierror:
         # hostname not found in DNS
         return None
         Args:
           hostname: hostname to look up
         Returns:
           a tuple (name, aliases, ipaddrs) as returned by socket.gethostbyname_ex
           in case of errors in resolving, we raise a ResolverError
         """
         try:
           result = socket.gethostbyname_ex(hostname)
         except socket.gaierror, err:
           # hostname not found in DNS
           raise errors.ResolverError(hostname, err.args[0], err.args[1])
       return HostInfo(name, aliases, ipaddrs)
         return result
     def ListVolumeGroups():

       def _init_cluster(self, cfg):
         """Initializes the cfg object"""
         cfg.InitConfig(socket.gethostname(), '127.0.0.1', None, '', 'aa:00:00',
         cfg.InitConfig(utils.HostInfo().name, '127.0.0.1', None, '', 'aa:00:00',
                        'xenvg', constants.DEFAULT_BRIDGE)
       def _create_instance(self):

     """Module implementing a fake ConfigWriter"""
     import socket
     from ganeti import utils
     class FakeConfig:
         """Fake configuration object"""
-...
             return ["a", "b", "c"]
         def GetMaster(self):
             return socket.gethostname()
             return utils.HostInfo().name
     class FakeSStore:
-...
             return "test.cluster"
         def GetMasterNode(self):
             return socket.gethostname()
             return utils.HostInfo().name

Synnefo » snf-ganeti

Revision 89e1fc26