Openstack nova service 启动过程

Openstack 中nova主要是用作运算，其是有多个service组成的。

在每个service启动的时候都会注册一个RPC server（nova-api 除外）以供RPC的client调用。

nova compute

nova/cmd/compute.py

def main():
config.parse_args(sys.argv)
logging.setup('nova')
utils.monkey_patch()
objects.register_all()

gmr.TextGuruMeditation.setup_autorun(version)

if not CONF.conductor.use_local:
block_db_access()
objects_base.NovaObject.indirection_api = \
conductor_rpcapi.ConductorAPI()

<em><strong> server = service.Service.create(binary='nova-compute',
topic=CONF.compute_topic,
db_allowed=CONF.conductor.use_local)
service.serve(server)
service.wait()</strong></em>

service在程序的开头通过import导入

from nova import service

Service 是定义在nova/service .py 里面的一个类

其create方法使用@classmethod 修饰因此可以直接使用类名调用。此方法的作用是返回一个service的对象。

def create(cls, host=None, binary=None, topic=None, manager=None,
report_interval=None, periodic_enable=None,
periodic_fuzzy_delay=None, periodic_interval_max=None,
db_allowed=True):
"""Instantiates class and passes back application object.

:param host: defaults to CONF.host
:param binary: defaults to basename of executable
:param topic: defaults to bin_name - 'nova-' part
:param manager: defaults to CONF.<topic>_manager
:param report_interval: defaults to CONF.report_interval
:param periodic_enable: defaults to CONF.periodic_enable
:param periodic_fuzzy_delay: defaults to CONF.periodic_fuzzy_delay
:param periodic_interval_max: if set, the max time to wait between runs

"""
if not host:
host = CONF.host
if not binary:
binary = os.path.basename(sys.argv[0])
if not topic:
topic = binary.rpartition('nova-')[2]
if not manager:
manager_cls = ('%s_manager' %
binary.rpartition('nova-')[2])
manager = CONF.get(manager_cls, None)
if report_interval is None:
report_interval = CONF.report_interval
if periodic_enable is None:
periodic_enable = CONF.periodic_enable
if periodic_fuzzy_delay is None:
periodic_fuzzy_delay = CONF.periodic_fuzzy_delay

debugger.init()

service_obj = cls(host, binary, topic, manager,
report_interval=report_interval,
periodic_enable=periodic_enable,
periodic_fuzzy_delay=periodic_fuzzy_delay,
periodic_interval_max=periodic_interval_max,
db_allowed=db_allowed)

return service_obj

<em><strong>service.serve(server)</strong></em>

用来启动service

nova/service.py

def serve(server, workers=None):
global _launcher
if _launcher:
raise RuntimeError(_('serve() can only be called once'))

_<strong><em>launcher = service.launch(server, workers=workers)</em></strong>

在 service.py 中 service在开头import

from nova.openstack.common import service

service中的launch的实现为（nova/openstack/common/service.py)

def launch(service, workers=1):
if workers is None or workers == 1:
launcher = ServiceLauncher()
launcher.launch_service(service)
else:
launcher = ProcessLauncher()
launcher.launch_service(service, workers=workers)

return launcher

此处有两种加载方法ServiceLauncher和ProcessLauncher

ServiceLauncher类中的launch_service 实现为：注意ServiceLauncher类中并没有单独定义此方法而是继承自其父类Launcher

<pre name="code" class="python"> def launch_service(self, service):
"""Load and start the given service.

:param service: The service you would like to start.
:returns: None

"""
service.backdoor_port = self.backdoor_port
self.services.add(service)

services.add()方法实现使用了GreenThread关于Greenthraed会在单独一个文章里面介绍。

def add(self, service):
self.services.append(service)
self.tg.add_thread(self.run_service, service, self.done)

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

"""
service.start()
done.wait()

greenthread会执行run_service()方法。run_service()方法执行service.start()和done.wait()，完成了服务的启动，然后等待，一开始我看到Service类中有个start()方法，知道一个服务的启动实质性的内容都在这个方法里，但是就是找不到在哪里调用了这个方法，原来是在这里。。

def start(self):
verstr = version.version_string_with_package()
LOG.audit(_('Starting %(topic)s node (version %(version)s)'),
{'topic': self.topic, 'version': verstr})
self.basic_config_check()
self.manager.init_host()
self.model_disconnected = False
ctxt = context.get_admin_context()
try:
self.service_ref = self.conductor_api.service_get_by_args(ctxt,
self.host, self.binary)
self.service_id = self.service_ref['id']
except exception.NotFound:
try:
self.service_ref = self._create_service_ref(ctxt)
except (exception.ServiceTopicExists,
exception.ServiceBinaryExists):
# NOTE(danms): If we race to create a record with a sibling
# worker, don't fail here.
self.service_ref = self.conductor_api.service_get_by_args(ctxt,
self.host, self.binary)

self.manager.pre_start_hook()

if self.backdoor_port is not None:
self.manager.backdoor_port = self.backdoor_port

LOG.debug("Creating RPC server for service %s", self.topic)

target = messaging.Target(topic=self.topic, server=self.host)

endpoints = [
self.manager,
baserpc.BaseRPCAPI(self.manager.service_name, self.backdoor_port)
]
endpoints.extend(self.manager.additional_endpoints)

serializer = objects_base.NovaObjectSerializer()

self.rpcserver = rpc.get_server(target, endpoints, serializer)
self.rpcserver.start()

self.manager.post_start_hook()

LOG.debug("Join ServiceGroup membership for this service %s",

4000
self.topic)
# Add service to the ServiceGroup membership group.
self.servicegroup_api.join(self.host, self.topic, self)

if self.periodic_enable:
if self.periodic_fuzzy_delay:
initial_delay = random.randint(0, self.periodic_fuzzy_delay)
else:
initial_delay = None

self.tg.add_dynamic_timer(self.periodic_tasks,
initial_delay=initial_delay,
periodic_interval_max=
self.periodic_interval_max)

def get_server(target, endpoints, serializer=None):
assert TRANSPORT is not None
serializer = RequestContextSerializer(serializer)
return messaging.get_rpc_server(TRANSPORT,
target,
endpoints,
executor='eventlet',
serializer=serializer)