def _test_cast(self, fanout, server_params=None):
self.mock_connection = self.mox.CreateMock(self.orig_connection)
self.mock_session = self.mox.CreateMock(self.orig_session)
self.mock_sender = self.mox.CreateMock(self.orig_sender)
self.mock_connection.opened().AndReturn(False)
self.mock_connection.open()
self.mock_connection.session().AndReturn(self.mock_session)
if fanout:
expected_address = ('impl_qpid_test_fanout ; '
'{"node": {"x-declare": {"auto-delete": true, '
'"durable": false, "type": "fanout"}, '
'"type": "topic"}, "create": "always"}')
else:
expected_address = (
'openstack/impl_qpid_test ; {"node": {"x-declare": '
'{"auto-delete": true, "durable": false}, "type": "topic"}, '
'"create": "always"}')
self.mock_session.sender(expected_address).AndReturn(self.mock_sender)
self.mock_sender.send(mox.IgnoreArg())
if not server_params:
# This is a pooled connection, so instead of closing it, it
# gets reset, which is just creating a new session on the
# connection.
self.mock_session.close()
self.mock_connection.session().AndReturn(self.mock_session)
self.mox.ReplayAll()
try:
ctx = context.RequestContext("user", "project")
args = [
FLAGS, ctx, "impl_qpid_test", {
"method": "test_method",
"args": {}
}
]
if server_params:
args.insert(2, server_params)
if fanout:
method = impl_qpid.fanout_cast_to_server
else:
method = impl_qpid.cast_to_server
else:
if fanout:
method = impl_qpid.fanout_cast
else:
method = impl_qpid.cast
method(*args)
finally:
while impl_qpid.Connection.pool.free_items:
# Pull the mock connection object out of the connection pool so
# that it doesn't mess up other test cases.
impl_qpid.Connection.pool.get()
def _make_zone_request(zone, is_admin=False):
ctxt = context.RequestContext('fake', 'fake', is_admin=is_admin)
return {
'context': ctxt,
'request_spec': {
'resource_properties': {
'availability_zone': zone
}
}
}
def _test_call_with_timeout(self, timeout, expect_failure):
self._test_call_mock_common()
if not expect_failure:
self.mock_session.next_receiver(timeout=None).AndReturn(
self.mock_receiver)
self.mock_receiver.fetch().AndReturn(
qpid.messaging.Message({
"_msg_id": self.uuid4.hex,
"result": "foo",
"failure": False,
"ending": False
}))
self.mock_session.acknowledge(mox.IgnoreArg())
self.mock_session.next_receiver(timeout=None).AndReturn(
self.mock_receiver)
self.mock_receiver.fetch().AndReturn(
qpid.messaging.Message({
"_msg_id": self.uuid4.hex,
"failure": False,
"ending": True
}))
self.mock_session.acknowledge(mox.IgnoreArg())
# Normally the iterconsume() runs indefinitely, but we have to stop it
# here otherwise, the test won't end
self.mock_session.next_receiver(timeout=None).AndRaise(StopIteration)
self.mock_connection.close()
self.mox.ReplayAll()
try:
ctx = context.RequestContext("user", "project")
method = impl_qpid.call
if expect_failure:
try:
res = method(self.FLAGS, ctx, "impl_qpid_test", {
"method": "test_method",
"args": {}
}, timeout)
self.fail('Expected a timeout exception')
except rpc_common.Timeout:
# Good, this is expected!
pass
else:
res = method(self.FLAGS, ctx, "impl_qpid_test", {
"method": "test_method",
"args": {}
}, timeout)
self.assertEqual(res, "foo")
finally:
impl_qpid.cleanup()
self.uuid4 = uuid.uuid4()
def setUp(self):
super(HostFiltersTestCase, self).setUp()
self.context = context.RequestContext('fake', 'fake')
self.json_query = jsonutils.dumps([
'and', ['>=', '$free_ram_mb', 1024],
['>=', '$free_disk_mb', 200 * 1024]
])
namespace = 'openstack.common.scheduler.filters'
filter_handler = filters.HostFilterHandler(namespace)
classes = filter_handler.get_all_classes()
self.class_map = {}
for cls in classes:
self.class_map[cls.__name__] = cls
def test_serializer(self):
ctxt = context.RequestContext('fake', 'fake')
serializer = rpc_serializer.NoOpSerializer()
self.mox.StubOutWithMock(serializer, 'serialize_entity')
self.mox.StubOutWithMock(serializer, 'deserialize_entity')
self.mox.StubOutWithMock(rpc, 'call')
serializer.serialize_entity(ctxt, 1).AndReturn(1)
serializer.serialize_entity(ctxt, 2).AndReturn(2)
rpc.call(ctxt, 'fake',
{'args': {'a': 1, 'b': 2},
'namespace': None,
'method': 'foo',
'version': '1.0'},
None).AndReturn('foo')
serializer.deserialize_entity(ctxt, 'foo').AndReturn('worked!')
self.mox.ReplayAll()
rpc_proxy = proxy.RpcProxy('fake', '1.0', serializer=serializer)
msg = rpc_proxy.make_msg('foo', a=1, b=2)
result = rpc_proxy.call(ctxt, msg)
self.assertEqual(result, 'worked!')
def setUp(self):
super(RpcDispatcherTestCase, self).setUp()
self.ctxt = context.RequestContext('fake_user', 'fake_project')
self.mox = self.useFixture(moxstubout.MoxStubout()).mox
def _test_call(self, multi):
self.mock_connection = self.mox.CreateMock(self.orig_connection)
self.mock_session = self.mox.CreateMock(self.orig_session)
self.mock_sender = self.mox.CreateMock(self.orig_sender)
self.mock_receiver = self.mox.CreateMock(self.orig_receiver)
self.mock_connection.opened().AndReturn(False)
self.mock_connection.open()
self.mock_connection.session().AndReturn(self.mock_session)
rcv_addr = mox.Regex(
r'^.*/.* ; {"node": {"x-declare": {"auto-delete":'
' true, "durable": true, "type": "direct"}, "type": '
'"topic"}, "create": "always", "link": {"x-declare": '
'{"auto-delete": true, "exclusive": true, "durable": '
'false}, "durable": true, "name": ".*"}}')
self.mock_session.receiver(rcv_addr).AndReturn(self.mock_receiver)
self.mock_receiver.capacity = 1
send_addr = (
'openstack/impl_qpid_test ; {"node": {"x-declare": '
'{"auto-delete": true, "durable": false}, "type": "topic"}, '
'"create": "always"}')
self.mock_session.sender(send_addr).AndReturn(self.mock_sender)
self.mock_sender.send(mox.IgnoreArg())
self.mock_session.next_receiver(timeout=mox.IsA(int)).AndReturn(
self.mock_receiver)
self.mock_receiver.fetch().AndReturn(
qpid.messaging.Message({
"result": "foo",
"failure": False,
"ending": False
}))
self.mock_session.acknowledge(mox.IgnoreArg())
if multi:
self.mock_session.next_receiver(timeout=mox.IsA(int)).AndReturn(
self.mock_receiver)
self.mock_receiver.fetch().AndReturn(
qpid.messaging.Message({
"result": "bar",
"failure": False,
"ending": False
}))
self.mock_session.acknowledge(mox.IgnoreArg())
self.mock_session.next_receiver(timeout=mox.IsA(int)).AndReturn(
self.mock_receiver)
self.mock_receiver.fetch().AndReturn(
qpid.messaging.Message({
"result": "baz",
"failure": False,
"ending": False
}))
self.mock_session.acknowledge(mox.IgnoreArg())
self.mock_session.next_receiver(timeout=mox.IsA(int)).AndReturn(
self.mock_receiver)
self.mock_receiver.fetch().AndReturn(
qpid.messaging.Message({
"failure": False,
"ending": True
}))
self.mock_session.acknowledge(mox.IgnoreArg())
self.mock_session.close()
self.mock_connection.session().AndReturn(self.mock_session)
self.mox.ReplayAll()
try:
ctx = context.RequestContext("user", "project")
if multi:
method = impl_qpid.multicall
else:
method = impl_qpid.call
res = method(FLAGS, ctx, "impl_qpid_test", {
"method": "test_method",
"args": {}
})
if multi:
self.assertEquals(list(res), ["foo", "bar", "baz"])
else:
self.assertEquals(res, "foo")
finally:
while impl_qpid.Connection.pool.free_items:
# Pull the mock connection object out of the connection pool so
# that it doesn't mess up other test cases.
impl_qpid.Connection.pool.get()
def _test_rpc_method(self, rpc_method, has_timeout=False, has_retval=False,
server_params=None, supports_topic_override=True):
topic = 'fake_topic'
rpc_proxy = proxy.RpcProxy(topic, '1.0')
ctxt = context.RequestContext('fake_user', 'fake_project')
msg = {'method': 'fake_method', 'args': {'x': 'y'}}
expected_msg = {'method': 'fake_method', 'args': {'x': 'y'},
'version': '1.0'}
expected_retval = 'hi' if has_retval else None
self.fake_args = None
self.fake_kwargs = None
def _fake_rpc_method(*args, **kwargs):
rpc._check_for_lock()
self.fake_args = args
self.fake_kwargs = kwargs
if has_retval:
return expected_retval
def _fake_rpc_method_timeout(*args, **kwargs):
rpc._check_for_lock()
self.fake_args = args
self.fake_kwargs = kwargs
raise rpc_common.Timeout("The spider got you")
def _check_args(context, topic, msg, timeout=None):
expected_args = [context, topic, msg]
if server_params:
expected_args.insert(1, server_params)
if has_timeout:
expected_args.append(timeout)
self.assertEqual(tuple(expected_args), self.fake_args)
self.stubs.Set(rpc, rpc_method, _fake_rpc_method)
args = [ctxt, msg]
if server_params:
args.insert(1, server_params)
# Base method usage
retval = getattr(rpc_proxy, rpc_method)(*args)
self.assertEqual(retval, expected_retval)
_check_args(ctxt, topic, expected_msg)
# overriding the version
retval = getattr(rpc_proxy, rpc_method)(*args, version='1.1')
self.assertEqual(retval, expected_retval)
new_msg = copy.deepcopy(expected_msg)
new_msg['version'] = '1.1'
_check_args(ctxt, topic, new_msg)
# override the version to be above a specified cap
rpc_proxy.version_cap = '1.0'
self.assertRaises(rpc_common.RpcVersionCapError,
getattr(rpc_proxy, rpc_method), *args, version='1.1')
rpc_proxy.version_cap = None
if has_timeout:
# Set a timeout
retval = getattr(rpc_proxy, rpc_method)(ctxt, msg, timeout=42)
self.assertEqual(retval, expected_retval)
_check_args(ctxt, topic, expected_msg, timeout=42)
# Make it timeout and check that the exception is written as
# expected
self.stubs.Set(rpc, rpc_method, _fake_rpc_method_timeout)
try:
getattr(rpc_proxy, rpc_method)(*args, timeout=42)
self.fail("This should have raised a Timeout exception")
except rpc_common.Timeout as exc:
self.assertEqual(exc.info, 'The spider got you')
self.assertEqual(exc.topic, 'fake_topic')
self.assertEqual(exc.method, 'fake_method')
self.assertEqual(
u'Timeout while waiting on RPC response - '
'topic: "fake_topic", RPC method: "fake_method" '
'info: "The spider got you"', six.text_type(exc))
_check_args(ctxt, topic, expected_msg, timeout=42)
self.stubs.Set(rpc, rpc_method, _fake_rpc_method)
if supports_topic_override:
# set a topic
new_topic = 'foo.bar'
retval = getattr(rpc_proxy, rpc_method)(*args, topic=new_topic)
self.assertEqual(retval, expected_retval)
_check_args(ctxt, new_topic, expected_msg)
def _test_call_with_timeout(self, timeout, expect_failure):
# TODO(beagles): should be possible to refactor this method and
# _test_call to share common code. Maybe making the messages
# and test checks parameters, etc.
self.mock_connection = self.mox.CreateMock(self.orig_connection)
self.mock_session = self.mox.CreateMock(self.orig_session)
self.mock_sender = self.mox.CreateMock(self.orig_sender)
self.mock_receiver = self.mox.CreateMock(self.orig_receiver)
self.mock_connection.opened().AndReturn(False)
self.mock_connection.open()
self.mock_connection.session().AndReturn(self.mock_session)
rcv_addr = mox.Regex(
r'^.*/.* ; {"node": {"x-declare": {"auto-delete":'
' true, "durable": true, "type": "direct"}, "type": '
'"topic"}, "create": "always", "link": {"x-declare": '
'{"auto-delete": true, "exclusive": true, "durable": '
'false}, "durable": true, "name": ".*"}}')
self.mock_session.receiver(rcv_addr).AndReturn(self.mock_receiver)
self.mock_receiver.capacity = 1
send_addr = (
'openstack/impl_qpid_test ; {"node": {"x-declare": '
'{"auto-delete": true, "durable": false}, "type": "topic"}, '
'"create": "always"}')
self.mock_session.sender(send_addr).AndReturn(self.mock_sender)
self.mock_sender.send(mox.IgnoreArg())
if expect_failure:
self.mock_session.next_receiver(timeout=mox.IsA(int)).AndRaise(
qpid.messaging.exceptions.Empty())
self.mock_receiver.fetch()
self.mock_session.close()
self.mock_connection.session().AndReturn(self.mock_session)
else:
self.mock_session.next_receiver(timeout=mox.IsA(int)).AndReturn(
self.mock_receiver)
self.mock_receiver.fetch().AndReturn(qpid.messaging.Message(
{"result": "foo", "failure": False, "ending": False}))
self.mock_session.acknowledge(mox.IgnoreArg())
self.mock_session.next_receiver(timeout=mox.IsA(int)).AndReturn(
self.mock_receiver)
self.mock_receiver.fetch().AndReturn(qpid.messaging.Message(
{"failure": False, "ending": True}))
self.mock_session.acknowledge(mox.IgnoreArg())
self.mock_session.close()
self.mock_connection.session().AndReturn(self.mock_session)
self.mox.ReplayAll()
try:
ctx = context.RequestContext("user", "project")
method = impl_qpid.call
if expect_failure:
try:
res = method(FLAGS, ctx, "impl_qpid_test",
{"method": "test_method", "args": {}},
timeout)
self.fail('Expected a timeout exception')
except rpc_common.Timeout:
# Good, this is expected!
pass
else:
res = method(FLAGS, ctx, "impl_qpid_test",
{"method": "test_method", "args": {}}, timeout)
self.assertEquals(res, "foo")
finally:
while impl_qpid.Connection.pool.free_items:
# Pull the mock connection object out of the connection pool so
# that it doesn't mess up other test cases.
impl_qpid.Connection.pool.get()
def test_context(self):
ctx = context.RequestContext()
self.assertTrue(ctx)
def _test_rpc_method(self,
rpc_method,
has_timeout=False,
has_retval=False,
server_params=None,
supports_topic_override=True):
topic = 'fake_topic'
timeout = 123
rpc_proxy = proxy.RpcProxy(topic, '1.0')
ctxt = context.RequestContext('fake_user', 'fake_project')
msg = {'method': 'fake_method', 'args': {'x': 'y'}}
expected_msg = {
'method': 'fake_method',
'args': {
'x': 'y'
},
'version': '1.0'
}
expected_retval = 'hi' if has_retval else None
self.fake_args = None
self.fake_kwargs = None
def _fake_rpc_method(*args, **kwargs):
self.fake_args = args
self.fake_kwargs = kwargs
if has_retval:
return expected_retval
self.stubs.Set(rpc, rpc_method, _fake_rpc_method)
args = [ctxt, msg]
if server_params:
args.insert(1, server_params)
# Base method usage
retval = getattr(rpc_proxy, rpc_method)(*args)
self.assertEqual(retval, expected_retval)
expected_args = [ctxt, topic, expected_msg]
if server_params:
expected_args.insert(1, server_params)
for arg, expected_arg in zip(self.fake_args, expected_args):
self.assertEqual(arg, expected_arg)
# overriding the version
retval = getattr(rpc_proxy, rpc_method)(*args, version='1.1')
self.assertEqual(retval, expected_retval)
new_msg = copy.deepcopy(expected_msg)
new_msg['version'] = '1.1'
expected_args = [ctxt, topic, new_msg]
if server_params:
expected_args.insert(1, server_params)
for arg, expected_arg in zip(self.fake_args, expected_args):
self.assertEqual(arg, expected_arg)
if has_timeout:
# set a timeout
retval = getattr(rpc_proxy, rpc_method)(ctxt, msg, timeout=timeout)
self.assertEqual(retval, expected_retval)
expected_args = [ctxt, topic, expected_msg, timeout]
for arg, expected_arg in zip(self.fake_args, expected_args):
self.assertEqual(arg, expected_arg)
if supports_topic_override:
# set a topic
new_topic = 'foo.bar'
retval = getattr(rpc_proxy, rpc_method)(*args, topic=new_topic)
self.assertEqual(retval, expected_retval)
expected_args = [ctxt, new_topic, expected_msg]
if server_params:
expected_args.insert(1, server_params)
for arg, expected_arg in zip(self.fake_args, expected_args):
self.assertEqual(arg, expected_arg)
def setUp(self):
super(RpcDispatcherTestCase, self).setUp()
self.ctxt = context.RequestContext('fake_user', 'fake_project')
def _fake_context():
return context.RequestContext(1, 1)
def _test_call(self, multi, reply_proxy_exc):
self._test_call_mock_common()
if reply_proxy_exc:
self.mock_session.next_receiver(timeout=None).AndRaise(
Exception('unexpected exception'))
self.mock_session.next_receiver(timeout=None).AndReturn(
self.mock_receiver)
self.mock_receiver.fetch().AndReturn(
qpid.messaging.Message({
"_msg_id": self.uuid4.hex,
"result": "foo",
"failure": False,
"ending": False
}))
self.mock_session.acknowledge(mox.IgnoreArg())
if multi:
self.mock_session.next_receiver(timeout=None).AndReturn(
self.mock_receiver)
self.mock_receiver.fetch().AndReturn(
qpid.messaging.Message({
"_msg_id": self.uuid4.hex,
"result": "bar",
"failure": False,
"ending": False
}))
self.mock_session.acknowledge(mox.IgnoreArg())
self.mock_session.next_receiver(timeout=None).AndReturn(
self.mock_receiver)
self.mock_receiver.fetch().AndReturn(
qpid.messaging.Message({
"_msg_id": self.uuid4.hex,
"result": "baz",
"failure": False,
"ending": False
}))
self.mock_session.acknowledge(mox.IgnoreArg())
if reply_proxy_exc:
self.mock_session.next_receiver(timeout=None).AndRaise(
Exception('unexpected exception'))
self.mock_session.next_receiver(timeout=None).AndReturn(
self.mock_receiver)
self.mock_receiver.fetch().AndReturn(
qpid.messaging.Message({
"_msg_id": self.uuid4.hex,
"failure": False,
"ending": True
}))
self.mock_session.acknowledge(mox.IgnoreArg())
# Normally the iterconsume() runs indefinitely, but we have to stop it
# here otherwise, the test won't end
self.mock_session.next_receiver(timeout=None).AndRaise(StopIteration)
self.mock_connection.close()
self.mox.ReplayAll()
try:
ctx = context.RequestContext("user", "project")
if multi:
method = impl_qpid.multicall
else:
method = impl_qpid.call
res = method(self.FLAGS, ctx, "impl_qpid_test", {
"method": "test_method",
"args": {}
})
if multi:
self.assertEqual(list(res), ["foo", "bar", "baz"])
else:
self.assertEqual(res, "foo")
finally:
impl_qpid.cleanup()
self.uuid4 = uuid.uuid4()
def _test_cast(self, fanout, server_params=None, topology_version=1):
self.config(qpid_topology_version=topology_version)
self.mock_connection = self.mox.CreateMock(self.orig_connection)
self.mock_session = self.mox.CreateMock(self.orig_session)
self.mock_sender = self.mox.CreateMock(self.orig_sender)
self.mock_connection.opened().AndReturn(False)
self.mock_connection.open()
self.mock_connection.session().AndReturn(self.mock_session)
if fanout:
if topology_version == 1:
expected_address = (
'impl_qpid_test_fanout ; '
'{"node": {"x-declare": {"auto-delete": true, '
'"durable": false, "type": "fanout"}, '
'"type": "topic"}, "create": "always"}')
elif topology_version == 2:
expected_address = 'amq.topic/fanout/impl_qpid_test'
else:
if topology_version == 1:
expected_address = (
'openstack/impl_qpid_test ; {"node": {"x-declare": '
'{"auto-delete": true, "durable": false}, '
'"type": "topic"}, "create": "always"}')
elif topology_version == 2:
expected_address = 'amq.topic/topic/openstack/impl_qpid_test'
self.mock_session.sender(expected_address).AndReturn(self.mock_sender)
self.mock_sender.send(mox.IgnoreArg())
if not server_params:
# This is a pooled connection, so instead of closing it, it
# gets reset, which is just creating a new session on the
# connection.
self.mock_session.close()
self.mock_connection.session().AndReturn(self.mock_session)
self.mock_connection.close()
self.mox.ReplayAll()
try:
ctx = context.RequestContext("user", "project")
args = [
self.FLAGS, ctx, "impl_qpid_test", {
"method": "test_method",
"args": {}
}
]
if server_params:
args.insert(2, server_params)
if fanout:
method = impl_qpid.fanout_cast_to_server
else:
method = impl_qpid.cast_to_server
else:
if fanout:
method = impl_qpid.fanout_cast
else:
method = impl_qpid.cast
method(*args)
finally:
impl_qpid.cleanup()
self.uuid4 = uuid.uuid4()
