Ocata Neutron代码分析——oslo_service中的ServiceLauncher和ProcessLauncher(转载)

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Ocata Neutron代码分析——oslo_service中的ServiceLauncher和ProcessLauncher(转载)相关的知识,希望对你有一定的参考价值。

1.概述
 
Openstack中有一个叫Launcher的概念,即专门用来启动服务的,这个类被放在了oslo_service这个包里面。Launcher分为两种,一种是ServiceLauncher,另一种为ProcessLauncher。ServiceLauncher用来启动单进程的服务,而ProcessLauncher用来启动有多个worker子进程的服务。
 
2.ServiceLauncher
 
ServiceLauncher继承自Launcher,启动服务的一个重要成员就是launcher_service,ServiceLauncher没有对该成员函数进行任何改写。
def launch_service(self, service, workers=1):
        """Load and start the given service.

        :param service: The service you would like to start, must be an
                        instance of :class:`oslo_service.service.ServiceBase`
        :param workers: This param makes this method compatible with
                        ProcessLauncher.launch_service. It must be None, 1 or
                        omitted.
        :returns: None

        """
        if workers is not None and workers != 1:
            raise ValueError(_("Launcher asked to start multiple workers"))
        _check_service_base(service)
        service.backdoor_port = self.backdoor_port
        self.services.add(service)

 laucher_service就是将服务添加到self.services成员里面,services成员的类型是class Services,看看它的add方法。

class Services(object):

    def __init__(self):
        self.services = []
        self.tg = threadgroup.ThreadGroup()
        self.done = event.Event()

    def add(self, service):
        """Add a service to a list and create a thread to run it.

        :param service: service to run
        """
        self.services.append(service)
        self.tg.add_thread(self.run_service, service, self.done)

    @staticmethod
    def run_service(service, done):
        """Service start wrapper.

        :param service: service to run
        :param done: event to wait on until a shutdown is triggered
        :returns: None

        """
        try:
            service.start()
        except Exception:
            LOG.exception(Error starting thread.)
            raise SystemExit(1)
        else:
            done.wait()
Services这个类的初始化很简单,即创建一个ThreadGroup,ThreadGroup其实是eventlet的GreenPool,Openstack利用eventlet实现并发。add方法,将self.run_service这个方法放入pool中,而service就是它的参数。run_service方法很简单,就是调用service的start方法,这样就完成了服务的启动。
 
3.ProcessLauncher
 
ProcessLauncher直接继承于Object,所以其对launch_service方法进行了实现。
class ProcessLauncher(object):
    def launch_service(self, service, workers=1):
        """Launch a service with a given number of workers.

       :param service: a service to launch, must be an instance of
              :class:`oslo_service.service.ServiceBase`
       :param workers: a number of processes in which a service
              will be running
        """
        _check_service_base(service)
        wrap = ServiceWrapper(service, workers)

        LOG.info(Starting %d workers, wrap.workers)
        while self.running and len(wrap.children) < wrap.workers:
            self._start_child(wrap)

 lauch_service除了接受service参数以外,还需要接受一个workers参数,即子进程的个数,然后调用_start_child启动多个子进程。

    def _start_child(self, wrap):
        if len(wrap.forktimes) > wrap.workers:
            # Limit ourselves to one process a second (over the period of
            # number of workers * 1 second). This will allow workers to
            # start up quickly but ensure we don‘t fork off children that
            # die instantly too quickly.
            if time.time() - wrap.forktimes[0] < wrap.workers:
                LOG.info(Forking too fast, sleeping)
                time.sleep(1)

            wrap.forktimes.pop(0)

        wrap.forktimes.append(time.time())

        pid = os.fork()
        if pid == 0:
            self.launcher = self._child_process(wrap.service)
            while True:
                self._child_process_handle_signal()
                status, signo = self._child_wait_for_exit_or_signal(
                    self.launcher)
                if not _is_sighup_and_daemon(signo):
                    self.launcher.wait()
                    break
                self.launcher.restart()

            os._exit(status)

        LOG.debug(Started child %d, pid)

        wrap.children.add(pid)
        self.children[pid] = wrap

        return pid

_start_child只是简单的调用了一个os.fork(),然后子进程开始运行,子进程调用_child_process。

   def _child_process(self, service):
        self._child_process_handle_signal()

        # Reopen the eventlet hub to make sure we don‘t share an epoll
        # fd with parent and/or siblings, which would be bad
        eventlet.hubs.use_hub()

        # Close write to ensure only parent has it open
        os.close(self.writepipe)
        # Create greenthread to watch for parent to close pipe
        eventlet.spawn_n(self._pipe_watcher)

        # Reseed random number generator
        random.seed()

        launcher = Launcher(self.conf, restart_method=self.restart_method)
        launcher.launch_service(service)
        return launcher

 

 _child_process其实很简单,创建一个Launcher,调用Laucher.launch_service方法。前面介绍过ServiceLauncher继承自Launcher,也是调用的launch_service方法,将服务启动,因此接下来的步骤与前面一致,最终都将调用service.start方法启动服务。

以上是关于Ocata Neutron代码分析——oslo_service中的ServiceLauncher和ProcessLauncher(转载)的主要内容,如果未能解决你的问题,请参考以下文章

Ocata Neutron代码分析——api-paste.ini分析

Ocata Neutron代码分析——oslo_service中的ServiceLauncher和ProcessLauncher(转载)

Ubuntu16.10安装Ocata之4:Neutron

##5 Neutron控制节点

##2 Neutron计算节点

openstack-6neutron(网络服务)