nova-compute启动分析-1

python启动脚本 bin/nova-compute

    utils.default_flagfile()  #设置flag文件路径.    flags.FLAGS(sys.argv)   #把flag文件中的参数放到args中。    logging.setup()           #设置日志    utils.monkey_patch()    server = service.Service.create(binary='nova-compute') #创建服务    service.serve(server)  #启动服务    service.wait()             #等待请求

下面我讲按6大步进行讲述：

第一步：utils.default_flagfile()

   if args is None:        args = sys.argv    for arg in args:        if arg.find('flagfile') != -1:            break    else:        if not os.path.isabs(filename):            # turn relative filename into an absolute path            script_dir = os.path.dirname(inspect.stack()[-1][1])            filename = os.path.abspath(os.path.join(script_dir, filename))        if not os.path.exists(filename):            filename = "./nova.conf"            if not os.path.exists(filename):                filename = '/etc/nova/nova.conf'        flagfile = '--flagfile=%s' % filename        args.insert(1, flagfile)     其实所完成的功能也就是把--flagfile=/etc/nova/nova.conf加到入参数列表中。

第二步：flags.FLAGS(sys.argv)

  flags.py中有一句
  FLAGS = FlagValues()，那么直接查看FlagValues()这个类，这个类是继承于gflags.FlagValues.

第三步：logging.setup()

这个是对这个服务开启日志功能。

第四步：server = service.Service.create(binary='nova-compute')

这个函数位于/nova/service.py: 类Service中

class Service(object):    """Service object for binaries running on hosts.    A service takes a manager and enables rpc by listening to queues based    on topic. It also periodically runs tasks on the manager and reports    it state to the database services table.""" 函数定义如下:   @classmethod     def create(cls, host=None, binary=None, topic=None, manager=None,               report_interval=None, periodic_interval=None):        """Instantiates class and passes back application object.        :param host: defaults to FLAGS.host        :param binary: defaults to basename of executable        :param topic: defaults to bin_name - 'nova-' part        :param manager: defaults to FLAGS.<topic>_manager        :param report_interval: defaults to FLAGS.report_interval        :param periodic_interval: defaults to FLAGS.periodic_interval        """        if not host:            host = FLAGS.host #host name  ‘nova’        if not binary:            binary = os.path.basename(inspect.stack()[-1][1]) # 这是因为python可以查看动栈的内容。                                                              # 所以可以得到压入栈中的脚本的名字  这时，binary="nova-compute"        if not topic:            topic = binary.rpartition('nova-')[2]             #设置topic的名字:也就是把 binary的nova-去掉。        if not manager:            manager = FLAGS.get('%s_manager' % topic, None)   #很明显这里得到的是compute_manager.        if not report_interval:            report_interval = FLAGS.report_interval        if not periodic_interval:            periodic_interval = FLAGS.periodic_interval        service_obj = cls(host, binary, topic, manager,                          report_interval, periodic_interval)   #利用 Service.__init__()构造函数生成一个对象        return service_obj

接下来我们看看Service.__init__()

def __init__(self, host, binary, topic, manager, report_interval=None,                 periodic_interval=None, *args, **kwargs):        self.host = host        self.binary = binary        self.topic = topic        self.manager_class_name = manager        manager_class = utils.import_class(self.manager_class_name)        self.manager = manager_class(host=self.host, *args, **kwargs)        self.report_interval = report_interval        self.periodic_interval = periodic_interval        super(Service, self).__init__(*args, **kwargs)        self.saved_args, self.saved_kwargs = args, kwargs        self.timers = []

1、指定host、binary、topic。这个相对简单。

        self.host = host
        self.binary = binary
        self.topic = topic

2、动态指定manager类，并动态生成实例 。

        self.manager_class_name = manager    #在create函数中指定。
        manager_class = utils.import_class(self.manager_class_name)  #动态地import此类。
        self.manager = manager_class(host=self.host, *args, **kwargs) #动态地生成这个类的实例 。

       那么这时会调用ComputeManager::__init__()函数

      我们进入ComputeManager::__init__()函数

     

 def __init__(self, compute_driver=None, *args, **kwargs):        """Load configuration options and connect to the hypervisor."""        # TODO(vish): sync driver creation logic with the rest of the system        #             and re-document the module docstring        if not compute_driver:            compute_driver = FLAGS.compute_driver   #这部分在后面会仔细分析                                    #cfg.StrOpt('compute_driver',default='nova.virt.connection.get_connection',                                    #help='Driver to use for controlling virtualization')        try:            self.driver = utils.check_isinstance(                                        utils.import_object(compute_driver),                                        driver.ComputeDriver)       #动态的加载 虚拟机的控制驱动对象        except ImportError as e:            LOG.error(_("Unable to load the virtualization driver: %s") % (e))            sys.exit(1)        self.network_api = network.API()        self.volume_api = volume.API()        self.network_manager = utils.import_object(FLAGS.network_manager)        self._last_host_check = 0        self._last_bw_usage_poll = 0        self._last_info_cache_heal = 0        super(ComputeManager, self).__init__(service_name="compute",                                             *args, **kwargs)

 这里顺便看一下ComputeManager的类视图。

  3、设置参数：应该是服务间隔时间之类的。

       self.report_interval = report_interval
        self.periodic_interval = periodic_interval

  4、 设置多出来的一些参数。      

        super(Service, self).__init__(*args, **kwargs)
        self.saved_args, self.saved_kwargs = args, kwargs
        self.timers = []

 第五步：service.serve(server)开启服务

def serve(*servers):    global _launcher  # class Launcher 一个全局对象    if not _launcher:        _launcher = Launcher()    for server in servers:        _launcher.launch_server(server)

  类Launcher 主要作用是为每个服务开启一个线程

 

  def launch_server(self, server):        """Load and start the given server.        :param server: The server you would like to start.        :returns: None        """        gt = eventlet.spawn(self.run_server, server)   #启动线程运行 run_server        self._services.append(gt)   #保存到 _services里面     @staticmethod    def run_server(server):        """Start and wait for a server to finish.        :param service: Server to run and wait for.        :returns: None        """        server.start()        server.wait()

其中server.start() #启动服务

我们来查看下 service.py中 Service类中start方法

 

 def start(self):        vcs_string = version.version_string_with_vcs()  #获取版本号        LOG.audit(_('Starting %(topic)s node (version %(vcs_string)s)'),                  {'topic': self.topic, 'vcs_string': vcs_string})        utils.cleanup_file_locks()  #清除锁文件        self.manager.init_host()          self.model_disconnected = False        ctxt = context.get_admin_context()        try:            service_ref = db.service_get_by_args(ctxt,                                                 self.host,                                                 self.binary)            self.service_id = service_ref['id']        except exception.NotFound:            self._create_service_ref(ctxt)        if 'nova-compute' == self.binary:            self.manager.update_available_resource(ctxt)        self.conn = rpc.create_connection(new=True)        LOG.debug(_("Creating Consumer connection for Service %s") %                  self.topic)        # Share this same connection for these Consumers        self.conn.create_consumer(self.topic, self, fanout=False)        node_topic = '%s.%s' % (self.topic, self.host)        self.conn.create_consumer(node_topic, self, fanout=False)        self.conn.create_consumer(self.topic, self, fanout=True)        # Consume from all consumers in a thread        self.conn.consume_in_thread()        if self.report_interval:            pulse = utils.LoopingCall(self.report_state)            pulse.start(interval=self.report_interval, now=False)            self.timers.append(pulse)        if self.periodic_interval:            periodic = utils.LoopingCall(self.periodic_tasks)            periodic.start(interval=self.periodic_interval, now=False)            self.timers.append(periodic)

下面我们对start方法进行分析：

 1、设置版本

        vcs_string = version.version_string_with_vcs()
        logging.audit(_('Starting %(topic)s node (version %(vcs_string)s)'),
                      {'topic': self.topic, 'vcs_string': vcs_string})

 2、初始化init_host(self): nova.compute.ComputeManager

    其中 self.driver.init_host(host=self.host)

    这里需要查看一下在__init__函数中driver的设置。

        if not compute_driver:
                   compute_driver = FLAGS.compute_driver
     FLAGS.compute_driver的值也是在/nova/compute/manager.py中设置：

    

    flags.DEFINE_string('compute_driver', 'nova.virt.connection.get_connection',
                    'Driver to use for controlling virtualization')

    关于get_connection下篇blog继续分析

3 . 接着从service.start()接着init_host()之后，

    得到context.然后再更新当前机器上可用的资源。 

        self.model_disconnected = False        ctxt = context.get_admin_context()        try:            service_ref = db.service_get_by_args(ctxt,                                                 self.host,                                                 self.binary)            self.service_id = service_ref['id']        except exception.NotFound:            self._create_service_ref(ctxt)        if 'nova-compute' == self.binary:            self.manager.update_available_resource(ctxt)

4. 更新RPC链接

 self.conn = rpc.create_connection(new=True)        LOG.debug(_("Creating Consumer connection for Service %s") %                  self.topic)           # Share this same connection for these Consumers        self.conn.create_consumer(self.topic, self, fanout=False)        node_topic = '%s.%s' % (self.topic, self.host)        self.conn.create_consumer(node_topic, self, fanout=False)        self.conn.create_consumer(self.topic, self, fanout=True)        # Consume from all consumers in a thread        self.conn.consume_in_thread()                  if self.report_interval:            pulse = utils.LoopingCall(self.report_state)        #循环调用report_state            pulse.start(interval=self.report_interval, now=False)            self.timers.append(pulse)        if self.periodic_interval:            periodic = utils.LoopingCall(self.periodic_tasks) #循环调用 periodic_tasks 下面详细说明            periodic.start(interval=self.periodic_interval, now=False)            self.timers.append(periodic)

 Nova-Compute启动的主要工作是把环境配置好。让RqbbitMQ的消息队列建立起来。最后服务的启动则主要是让rabbitmq的consumer运行。并且进入wait状态。消息的响应则主要是找到相应的函数地址，并执行之。

六. Wait() 等待

一般服务启动之后，都会有wait()。那么这里也需要看一下服务的wait()。从而可以知道是什么东西在后台真正地运行。

/usr/bin/nova-computeservice.wait()/nova/service.py:Class:Service::wait()    def wait(self):        for x in self.timers:            try:                x.wait()            except Exception:                pass