# These are decorators that mark an object's method as remotable.

# If the metaclass is configured to forward object methods to an

# indirection service, these will result in making an RPC call

# instead of directly calling the implementation in the object. Instead,

# the object implementation on the remote end will perform the

# requested action and the result will be returned here.

def remotable_classmethod(fn):

    """Decorator for remotable classmethods."""

    @six.wraps(fn)

    def wrapper(cls, context, *args, **kwargs):

        if cls.indirection_api:

            version_manifest = obj_tree_get_versions(cls.obj_name())

            try:

               # 需要设置indirection_api， 还需要提供 object_class_action_versions方法

                result = cls.indirection_api.object_class_action_versions(

                    context, cls.obj_name(), fn.__name__, version_manifest,

                    args, kwargs)

            except NotImplementedError:

                # FIXME(danms): Maybe start to warn here about deprecation?

                result = cls.indirection_api.object_class_action(

                    context, cls.obj_name(), fn.__name__, cls.VERSION,

                    args, kwargs)

        else:

            result = fn(cls, context, *args, **kwargs)

            if isinstance(result, VersionedObject):

                result._context = context

        return result

    # NOTE(danms): Make this discoverable

    wrapper.remotable = True

    wrapper.original_fn = fn

    return classmethod(wrapper)

# See comment above for remotable_classmethod()

#

# Note that this will use either the provided context, or the one

# stashed in the object. If neither are present, the object is

# "orphaned" and remotable methods cannot be called.

def remotable(fn):

    """Decorator for remotable object methods."""

    @six.wraps(fn)

    def wrapper(self, *args, **kwargs):

        ctxt = self._context

        if ctxt is None:

            raise exception.OrphanedObjectError(method=fn.__name__,

                                                objtype=self.obj_name())

        if self.indirection_api:

            # 需要设置indirection_api 及其 object_action 方法

            updates, result = self.indirection_api.object_action(

                ctxt, self, fn.__name__, args, kwargs)

            for key, value in updates.items():

                if key in self.fields:

                    field = self.fields[key]

                    # NOTE(ndipanov): Since VersionedObjectSerializer will have

                    # deserialized any object fields into objects already,

                    # we do not try to deserialize them again here.

                    if isinstance(value, VersionedObject):

                        setattr(self, key, value)

                    else:

                        setattr(self, key,

                                field.from_primitive(self, key, value))

            self.obj_reset_changes()

            self._changed_fields = set(updates.get('obj_what_changed', []))

            return result

        else:

            return fn(self, *args, **kwargs)

    wrapper.remotable = True

    wrapper.original_fn = fn

    return wrapper

def main():

    config.parse_args(sys.argv)

    logging.setup(CONF, 'nova')

    priv_context.init(root_helper=shlex.split(utils.get_root_helper()))

    utils.monkey_patch()

    objects.register_all()

    gmr_opts.set_defaults(CONF)

    # Ensure os-vif objects are registered and plugins loaded

    os_vif.initialize()

    gmr.TextGuruMeditation.setup_autorun(version, conf=CONF)

    cmd_common.block_db_access('nova-compute')

    objects_base.NovaObject.indirection_api = conductor_rpcapi.ConductorAPI()

    objects.Service.enable_min_version_cache()

    server = service.Service.create(binary='nova-compute',

                                    topic=compute_rpcapi.RPC_TOPIC)

    service.serve(server)

    service.wait()

from nova import compute

class ServersController(wsgi.Controller):

    """The Server API base controller class for the OpenStack API."""

    _view_builder_class = views_servers.ViewBuilder

    ......

    def __init__(self, **kwargs):

        super(ServersController, self).__init__(**kwargs)

        self.compute_api = compute.API()

class NovaObjectSerializer(messaging.NoOpSerializer):

    """A NovaObject-aware Serializer.

    This implements the Oslo Serializer interface and provides the

    ability to serialize and deserialize NovaObject entities. Any service

    that needs to accept or return NovaObjects as arguments or result values

    should pass this to its RPCClient and RPCServer objects.

    """

    @property

    def conductor(self):

        if not hasattr(self, '_conductor'):

            from nova import conductor

            self._conductor = conductor.API()

        return self._conductor

from nova import conductor

......

class Service(service.Service):

    """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

    its state to the database services table.

    """

    def __init__(self, host, binary, topic, manager, report_interval=None,

                 periodic_enable=None, periodic_fuzzy_delay=None,

                 periodic_interval_max=None, *args, **kwargs):

        super(Service, self).__init__()

        self.host = host

        self.binary = binary

        self.topic = topic

        self.manager_class_name = manager

        self.servicegroup_api = servicegroup.API()

        manager_class = importutils.import_class(self.manager_class_name)

        self.manager = manager_class(host=self.host, *args, **kwargs)

        self.rpcserver = None

        self.report_interval = report_interval

        self.periodic_enable = periodic_enable

        self.periodic_fuzzy_delay = periodic_fuzzy_delay

        self.periodic_interval_max = periodic_interval_max

        self.saved_args, self.saved_kwargs = args, kwargs

        self.backdoor_port = None

        if objects_base.NovaObject.indirection_api:

            conductor_api = conductor.API()

            conductor_api.wait_until_ready(context.get_admin_context())

        setup_profiler(binary, self.host)