97 lines
3.3 KiB
Python
97 lines
3.3 KiB
Python
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
|
|
|
# Copyright 2013 Red Hat, Inc.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
"""
|
|
A temporary helper which emulates oslo.messaging.rpc.RPCClient.
|
|
|
|
The most tedious part of porting to oslo.messaging is porting the code which
|
|
sub-classes RpcProxy to use RPCClient instead.
|
|
|
|
This helper method allows us to do that tedious porting as a standalone commit
|
|
so that the commit which switches us to oslo.messaging is smaller and easier
|
|
to review. This file will be removed as part of that commit.
|
|
"""
|
|
|
|
from nova.openstack.common.rpc import proxy
|
|
|
|
|
|
class RPCClient(object):
|
|
|
|
def __init__(self, proxy, namespace=None, server_params=None):
|
|
super(RPCClient, self).__init__()
|
|
self.proxy = proxy
|
|
self.namespace = namespace
|
|
self.server_params = server_params
|
|
self.kwargs = {}
|
|
self.fanout = None
|
|
|
|
def prepare(self, **kwargs):
|
|
# Clone ourselves
|
|
ret = self.__class__(self.proxy, self.namespace, self.server_params)
|
|
ret.kwargs.update(self.kwargs)
|
|
ret.fanout = self.fanout
|
|
|
|
# Update according to supplied kwargs
|
|
ret.kwargs.update(kwargs)
|
|
server = ret.kwargs.pop('server', None)
|
|
if server:
|
|
ret.kwargs['topic'] = '%s.%s' % (self.proxy.topic, server)
|
|
fanout = ret.kwargs.pop('fanout', None)
|
|
if fanout:
|
|
ret.fanout = True
|
|
|
|
return ret
|
|
|
|
def _invoke(self, cast_or_call, ctxt, method, **kwargs):
|
|
try:
|
|
msg = self.proxy.make_namespaced_msg(method,
|
|
self.namespace,
|
|
**kwargs)
|
|
return cast_or_call(ctxt, msg, **self.kwargs)
|
|
finally:
|
|
self.kwargs = {}
|
|
self.fanout = None
|
|
|
|
def cast(self, ctxt, method, **kwargs):
|
|
if self.server_params:
|
|
def cast_to_server(ctxt, msg, **kwargs):
|
|
if self.fanout:
|
|
return self.proxy.fanout_cast_to_server(
|
|
ctxt, self.server_params, msg, **kwargs)
|
|
else:
|
|
return self.proxy.cast_to_server(
|
|
ctxt, self.server_params, msg, **kwargs)
|
|
|
|
caster = cast_to_server
|
|
else:
|
|
caster = self.proxy.fanout_cast if self.fanout else self.proxy.cast
|
|
|
|
self._invoke(caster, ctxt, method, **kwargs)
|
|
|
|
def call(self, ctxt, method, **kwargs):
|
|
return self._invoke(self.proxy.call, ctxt, method, **kwargs)
|
|
|
|
def can_send_version(self, version):
|
|
return self.proxy.can_send_version(version)
|
|
|
|
|
|
class RpcProxy(proxy.RpcProxy):
|
|
|
|
def get_client(self, namespace=None, server_params=None):
|
|
return RPCClient(self,
|
|
namespace=namespace,
|
|
server_params=server_params)
|