概述

本文说一下 nova 数据库对象的远程使用。这是 nova 里很精彩的一个地方。
远程对象所实现的效果是，一个 A 服务中的远程对象实例，可以由消息队列传送到
B 服务，B 服务能够使用这个实例，当调用实例的方法时，实际执行这个方法却是在
A 服务中。

以 Instance 类的实例为例，该类是代表虚拟机数据库抽象的类，通常我们通过更改实例
的属性，并调用 Instance.save() 方法更改数据库。该类的定义在
nova/objects/instance.py 中。

nova-conductor 在收到创建虚拟机请求时生成了实例 instance = Instance()，之后将
instance 通过消息队列发送到了 nova-compute，在 nova-compute 进行虚拟机创建的
过程中，经常性地需要更改虚拟机的状态，所以经常出现类似这样的语句：

instance.task_state = task_states.XXX
instance.save()

nova-compute 不直接访问数据库，这个 save() 方法，就是由 nova-conductor 来执行的。

工作机制

nova-compute 中 instance 的方法调用都不是在本地执行的，实际上这些方法的调用都
转化为对远程 nova-conductor 服务中 instance 对象的 rpc 调用。

这里以 Instance 为例，许多 nova/objects/ 下的类都是同样的工作机制。通过追踪其
save() 方法，我们可以看到它有一个修饰函数：

@base.remotable
def save(self, context, expected_vm_state=None,
         expected_task_state=None, admin_state_reset=False):
    ...    ...

这个 base.remotable 就是搞怪的地方。我们追踪到 nova/objects/base.py 中的
remotable() 这个方法。 可以看出，它的骨架是这样的：

def remotable(fn):
    @functools.wraps(fn)
    def wrapper(self, *args, **kwargs):

        if NovaObject.indirection_api:
            updates, result = NovaObject.indirection_api.object_action(
                ctxt, self, fn.__name__, args, kwargs)
            return result
        else:
            return fn(self, ctxt, *args, **kwargs)

通过这个修饰函数的作用，当 save() 方法被调用的时候，其行为分入两个叉路，
其中一个是使用 NovaObject.indirection_api.object_action() 方法，另一个是
使用原 save() 方法。 而分叉的依据是 NovaObject.indirection_api 的值。

联想一下，nova-conductor 与 nova-compute 都调用了同样 Instance 类的同样的
save() 方法，其结果却不同，问题显然出在这个分叉路口。通过追踪
indirection_api 的变化，在 nova/cmd/compute.py 中找到了如下代码：

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

nova/cmd/compute.py 是 nova-compute 服务的入口文件，原来这里设置了这个值。
对于 nova-conductor 服务，没有人设置这个值，所以它是默认值 None。

这里有必要了解一下 CONF.conductor.use_local 这个配置参数，它是用来设置
nova-compute 是否直接访问数据库的。 nova-compute 默认是不能直接访问数据库
的，这个值在 nova/conductor/api.py 中设定，默认值为 False。

cfg.BoolOpt('use_local',
            default=False,
            help='Perform nova-conductor operations locally'),

如果想让 nova-compute 直接访问数据库，只需要打开这个配置项即可。

ConductorAPI

我们沿着 indirection_api 往下跟踪，看一下远程调用的具体实现。

由 nova/cmd/compute.py 中的设定，我们知道 indirection_api 是
conductor_rpcapi.ConductorAPI()，且无论是哪个对象， Instance() 也好，
SecurityGroup() 也好，调用的方法都是 object_action。代码如下：

class ConductorAPI(object):
    def __init__(self):
        super(ConductorAPI, self).__init__()
        target = messaging.Target(topic=CONF.conductor.topic, version='2.0')
        ... ...

    def object_action(self, context, objinst, objmethod, args, kwargs):
        cctxt = self.client.prepare()
        return cctxt.call(context, 'object_action', objinst=objinst,
                        objmethod=objmethod, args=args, kwargs=kwargs)

也就是说，这里直接将调用发送到消息队列之中了。需要注意的是几个参数，objinst
是远程对象的实例， objmethod 是想要调用的方法，args 和 kwargs 就不用说了。

这个调用是发往 CONF.conductor.topic 的，默认就是 “conductor”。在这个 topic 上
注册 rpc 方法的是 nova/conductor/manager.py 中的 ConductorManager()，来看它的
object_action 方法。

def object_action(self, context, objinst, objmethod, args, kwargs):
    """Perform an action on an object."""
    oldobj = objinst.obj_clone()
    result = self._object_dispatch(objinst, objmethod, context,
                                   args, kwargs)

    updates = dict()
    for name, field in objinst.fields.items():
        # 这里判断远程对象的哪些属性更改了，更改了的属性
        # 一起加到 updates 列表之中。
        ... ...
    # 返回更改以及方法的结果。
    return updates, result

def _object_dispatch(self, target, method, context, args, kwargs):
    try:
        return getattr(target, method)(context, *args, **kwargs)
    except Exception:
        raise messaging.ExpectedException()

方法的参数与 rpcapi 中调用时是一致的，所以很好理解，收到 objinst 和 objmethod
之后，在 nova-conductor 这边调用了 objinst.objmethod()。就是说远程对象是从
rpc 中发过来的，在发过来之前 nova-conductor 这边并没有对应的对象。相当于是说
nova-compute 告诉 nova-conductor，我这里有一个 instance 对象，我把它发给你，
它的那个 save() 方法，你帮我调用一下。

调用完成之后呢，需要将结果返回给 nova-compute，从上面代码可以看到，object_action()
方法返回了对象的更改以及方法的结果。 来看调用方 nova-compute 如何处理返回。
较完整的 base.remotable 方法。

def remotable(fn):
    @functools.wraps(fn)
    def wrapper(self, *args, **kwargs):

        if NovaObject.indirection_api:
            updates, result = NovaObject.indirection_api.object_action(
                ctxt, self, fn.__name__, args, kwargs)
            逐条
            for key, value in updates.iteritems():
                # 这里将 updates 中的更改，逐条检查更新到 nova-compute
                # 端的远程对象中。
                ... ...
            return result

所以概括来说，在调用的过程中，nova-conductor 与 nova-compute 两端共同维护了
远程对象的一致性，确保对象在两边是一模一样的。相当于 nova-conductor 与
nova-compute 两端有一个对象的两个一样的副本，当然对象的一致性是相对的，并不是
每时每刻都一致，更新是需要过程的。

经过以上的梳理，还有一个问题没有提及，那就是对象是如何在 rpc 中传递的。

序列化与反序列化

如果想要对象在 rpc 中传递，显然不能直接拿 python 的内存对象发来发去，消息在
传递的过程中有其独立的格式，例如 xml, json 等。将对象与消息格式之间的转化即
是序列化与反序列化。

nova/objects 中所提供的对象，如果需要支持远程使用的，都必须要提供序列化与反序列化
的方法。它们分别由 objfromprimitive() 和 objtoprimitive() 提供。

class NovaObject(object):
    def obj_to_primitive(self, target_version=None):
        # 序列化方法，将对象转化为原语 ，原语结构在这里本质上是字典。
        primitive = dict()
        for name, field in self.fields.items():
            # 对于对象的每个 field，都分别转化为原语，to_primitive 方法后面再讲。
            if self.obj_attr_is_set(name):
                primitive[name] = field.to_primitive(self, name,
                                                    getattr(self, name))
        if target_version:
            # 处理版本兼容问题。
            # 呃，远程对象是有版本的，便于软件升级过程中如果数据库有调整，
            # 不同的服务之间仍能协同工作。

            self.obj_make_compatible(primitive, target_version)
        # 最终转化完的结果是下面这个字典结构，可以看到
        # 这里有对象名称，命令空间，版本以及数据内容。
        # 涵盖了对象实例的所有信息，回头根据这些信息就可以重新制作一个一样的对象。
        obj = {'nova_object.name': self.obj_name(),
            'nova_object.namespace': 'nova',
            'nova_object.version': target_version or self.VERSION,
            'nova_object.data': primitive}
        # 远程对象在 rpc 调用过程中，需要记录两侧的更改，便于保持一致性。
        if self.obj_what_changed():
            obj['nova_object.changes'] = list(self.obj_what_changed())
        return obj

    @classmethod
    def obj_from_primitive(cls, primitive, context=None):
        # 反序列化方法，由原语生成对象。这里的工作就是从原语中
        # 获取到对象的信息，然后制作一个原语中描述的对象。
        if primitive['nova_object.namespace'] != 'nova':
            # 支持命令空间检查，对于 nova 来说命令空间必须是 nova。
            raise exception.UnsupportedObjectError(
                objtype='%s.%s' % (primitive['nova_object.namespace'],
                                primitive['nova_object.name']))
        # 设定对象的名称
        objname = primitive['nova_object.name']
        # 设定对象的版本
        objver = primitive['nova_object.version']
        # 根据名称与版本，获取到对象的类名。
        objclass = cls.obj_class_from_name(objname, objver)
        # 有了对象的类名，由数据内容生成对象的实例。
        return objclass._obj_from_primitive(context, objver, primitive)

    @classmethod
    def _obj_from_primitive(cls, context, objver, primitive):
        # 解析原语中数据内容，生成实例的方法。
        self = cls()
        self._context = context
        self.VERSION = objver
        objdata = primitive['nova_object.data']
        changes = primitive.get('nova_object.changes', [])
        for name, field in self.fields.items():
            if name in objdata:
                # 对于原语中的每一项数据，都使用 from_primitive 方法
                # 转化为一个 field。
                setattr(self, name, field.from_primitive(self, name,
                                                        objdata[name]))
        self._changed_fields = set([x for x in changes if x in self.fields])
        return self

下面看一下 nova 中的 Field 类。

class Field(object):

    def __init__(self, field_type, nullable=False,
                default=UnspecifiedDefault, read_only=False):
        # file_type 是 Integer, String, DataTime 等等的细分类型。
        # 每一种类型都有自己与原语转化的特定方式。
        self._type = field_type

    def from_primitive(self, obj, attr, value):
        if value is None:
            return None
        else:
            # 调用细分类型的转化方法
            return self._type.from_primitive(obj, attr, value)

    def to_primitive(self, obj, attr, value):
        if value is None:
            return None
        else:
            # 调用细分类型的转化方法
            return self._type.to_primitive(obj, attr, value)

对于普通类型，如 Integer，不需要特别的转化。而对于高级类型则需要一些程序，
以 IPAddress 为例：

class IPAddress(FieldType):
    @staticmethod
    def coerce(obj, attr, value):
        try:
            # 根据字符串初始化一个 IPAddress 类型。
            return netaddr.IPAddress(value)
        except netaddr.AddrFormatError as e:
            raise ValueError(six.text_type(e))

    def from_primitive(self, obj, attr, value):
        return self.coerce(obj, attr, value)

    @staticmethod
    def to_primitive(obj, attr, value):
        # 转化原语时，只需要转化为字符串即可。
        # IPAddress 类型需要提供 __str__ 方法。
        return str(value)