def test_published_with_per_meter_topic(self):
publisher = rpc.RPCPublisher(
network_utils.urlsplit('rpc://?per_meter_topic=1'))
with mock.patch.object(publisher.rpc_client, 'prepare') as prepare:
publisher.publish_samples(mock.MagicMock(), self.test_data)
class MeterGroupMatcher(object):
def __eq__(self, meters):
return len(set(meter['counter_name']
for meter in meters)) == 1
topic = self.CONF.publisher_rpc.metering_topic
expected = [
mock.call(topic=topic),
mock.call().cast(mock.ANY,
'record_metering_data',
data=mock.ANY),
mock.call(topic=topic + '.test'),
mock.call().cast(mock.ANY,
'record_metering_data',
data=MeterGroupMatcher()),
mock.call(topic=topic + '.test2'),
mock.call().cast(mock.ANY,
'record_metering_data',
data=MeterGroupMatcher()),
mock.call(topic=topic + '.test3'),
mock.call().cast(mock.ANY,
'record_metering_data',
data=MeterGroupMatcher())
]
self.assertEqual(expected, prepare.mock_calls)
def test_published_concurrency(self):
"""Test concurrent access to the local queue of the rpc publisher."""
publisher = rpc.RPCPublisher(network_utils.urlsplit('rpc://'))
cast_context = mock.MagicMock()
with mock.patch.object(publisher.rpc_client, 'prepare') as prepare:
def fake_prepare_go(topic):
return cast_context
def fake_prepare_wait(topic):
prepare.side_effect = fake_prepare_go
# Sleep to simulate concurrency and allow other threads to work
eventlet.sleep(0)
return cast_context
prepare.side_effect = fake_prepare_wait
job1 = eventlet.spawn(publisher.publish_samples, mock.MagicMock(),
self.test_data)
job2 = eventlet.spawn(publisher.publish_samples, mock.MagicMock(),
self.test_data)
job1.wait()
job2.wait()
self.assertEqual('default', publisher.policy)
self.assertEqual(2, len(cast_context.cast.mock_calls))
self.assertEqual(0, len(publisher.local_queue))
def test_published_with_policy_queue_and_rpc_down(self):
self.rpc_unreachable = True
publisher = rpc.RPCPublisher(
network_utils.urlsplit('rpc://?policy=queue'))
publisher.publish_samples(None, self.test_data)
self.assertEqual(len(self.published), 0)
self.assertEqual(len(publisher.local_queue), 1)
def test_published_concurrency(self):
"""This test the concurrent access to the local queue
of the rpc publisher
"""
def faux_cast_go(context, topic, msg):
self.published.append((topic, msg))
def faux_cast_wait(context, topic, msg):
self.stubs.Set(oslo_rpc, 'cast', faux_cast_go)
# Sleep to simulate concurrency and allow other threads to work
eventlet.sleep(0)
self.published.append((topic, msg))
self.stubs.Set(oslo_rpc, 'cast', faux_cast_wait)
publisher = rpc.RPCPublisher(network_utils.urlsplit('rpc://'))
job1 = eventlet.spawn(publisher.publish_samples, None, self.test_data)
job2 = eventlet.spawn(publisher.publish_samples, None, self.test_data)
job1.wait()
job2.wait()
self.assertEqual(publisher.policy, 'default')
self.assertEqual(len(self.published), 2)
self.assertEqual(len(publisher.local_queue), 0)
def test_published_concurrency(self):
"""This test the concurrent access to the local queue
of the rpc publisher
"""
def faux_cast_go(context, topic, msg):
self.published.append((topic, msg))
def faux_cast_wait(context, topic, msg):
self.useFixture(
fixtures.MonkeyPatch("ceilometer.openstack.common.rpc.cast",
faux_cast_go))
# Sleep to simulate concurrency and allow other threads to work
eventlet.sleep(0)
self.published.append((topic, msg))
self.useFixture(
fixtures.MonkeyPatch("ceilometer.openstack.common.rpc.cast",
faux_cast_wait))
publisher = rpc.RPCPublisher(network_utils.urlsplit('rpc://'))
job1 = eventlet.spawn(publisher.publish_samples, None, self.test_data)
job2 = eventlet.spawn(publisher.publish_samples, None, self.test_data)
job1.wait()
job2.wait()
self.assertEqual(publisher.policy, 'default')
self.assertEqual(len(self.published), 2)
self.assertEqual(len(publisher.local_queue), 0)
def test_published_with_policy_block(self):
self.rpc_unreachable = True
publisher = rpc.RPCPublisher(
network_utils.urlsplit('rpc://?policy=default'))
self.assertRaises(SystemExit, publisher.publish_samples, None,
self.test_data)
self.assertEqual(len(self.published), 0)
self.assertEqual(len(publisher.local_queue), 0)
def test_published(self):
publisher = rpc.RPCPublisher(network_utils.urlsplit('rpc://'))
publisher.publish_samples(None, self.test_data)
self.assertEqual(len(self.published), 1)
self.assertEqual(self.published[0][0],
self.CONF.publisher_rpc.metering_topic)
self.assertIsInstance(self.published[0][1]['args']['data'], list)
self.assertEqual(self.published[0][1]['method'],
'record_metering_data')
def test_publish_target(self):
publisher = rpc.RPCPublisher(
network_utils.urlsplit('rpc://?target=custom_procedure_call'))
publisher.publish_samples(None, self.test_data)
self.assertEqual(len(self.published), 1)
self.assertEqual(self.published[0][0],
self.CONF.publisher_rpc.metering_topic)
self.assertIsInstance(self.published[0][1]['args']['data'], list)
self.assertEqual(self.published[0][1]['method'],
'custom_procedure_call')
def test_published_with_policy_incorrect(self, mylog):
self.rpc_unreachable = True
publisher = rpc.RPCPublisher(
network_utils.urlsplit('rpc://?policy=notexist'))
self.assertRaises(SystemExit, publisher.publish_samples, None,
self.test_data)
self.assertTrue(mylog.warn.called)
self.assertEqual(publisher.policy, 'default')
self.assertEqual(len(self.published), 0)
self.assertEqual(len(publisher.local_queue), 0)
def test_published_with_policy_drop_and_rpc_down(self):
publisher = rpc.RPCPublisher(
network_utils.urlsplit('rpc://?policy=drop'))
side_effect = oslo.messaging._drivers.common.RPCException()
with mock.patch.object(publisher.rpc_client, 'prepare') as prepare:
prepare.side_effect = side_effect
publisher.publish_samples(mock.MagicMock(), self.test_data)
self.assertEqual(0, len(publisher.local_queue))
prepare.assert_called_once_with(
topic=self.CONF.publisher_rpc.metering_topic)
def test_published_with_no_policy(self, mylog):
self.rpc_unreachable = True
publisher = rpc.RPCPublisher(network_utils.urlsplit('rpc://'))
self.assertTrue(mylog.info.called)
self.assertRaises(SystemExit, publisher.publish_samples, None,
self.test_data)
self.assertEqual('default', publisher.policy)
self.assertEqual(0, len(self.published))
self.assertEqual(0, len(publisher.local_queue))
def test_published(self):
publisher = rpc.RPCPublisher(network_utils.urlsplit('rpc://'))
cast_context = mock.MagicMock()
with mock.patch.object(publisher.rpc_client, 'prepare') as prepare:
prepare.return_value = cast_context
publisher.publish_samples(mock.MagicMock(), self.test_data)
prepare.assert_called_once_with(
topic=self.CONF.publisher_rpc.metering_topic)
cast_context.cast.assert_called_once_with(mock.ANY,
'record_metering_data',
data=mock.ANY)
def test_published_with_policy_block(self, mylog):
publisher = rpc.RPCPublisher(
network_utils.urlsplit('rpc://?policy=default'))
side_effect = oslo.messaging._drivers.common.RPCException()
with mock.patch.object(publisher.rpc_client, 'prepare') as prepare:
prepare.side_effect = side_effect
self.assertRaises(oslo.messaging._drivers.common.RPCException,
publisher.publish_samples, mock.MagicMock(),
self.test_data)
self.assertTrue(mylog.info.called)
self.assertEqual(0, len(publisher.local_queue))
prepare.assert_called_once_with(
topic=self.CONF.publisher_rpc.metering_topic)
def test_published_with_policy_default_sized_queue_and_rpc_down(self):
publisher = rpc.RPCPublisher(
network_utils.urlsplit('rpc://?policy=queue'))
side_effect = oslo.messaging._drivers.common.RPCException()
with mock.patch.object(publisher.rpc_client, 'prepare') as prepare:
prepare.side_effect = side_effect
for i in range(0, 2000):
for s in self.test_data:
s.source = 'test-%d' % i
publisher.publish_samples(mock.MagicMock(), self.test_data)
self.assertEqual(1024, len(publisher.local_queue))
self.assertEqual('test-976', publisher.local_queue[0][2][0]['source'])
self.assertEqual('test-1999',
publisher.local_queue[1023][2][0]['source'])
def test_published_with_policy_default_sized_queue_and_rpc_down(self):
self.rpc_unreachable = True
publisher = rpc.RPCPublisher(
network_utils.urlsplit('rpc://?policy=queue'))
for i in range(2000):
for s in self.test_data:
s.source = 'test-%d' % i
publisher.publish_samples(None, self.test_data)
self.assertEqual(len(self.published), 0)
self.assertEqual(len(publisher.local_queue), 1024)
self.assertEqual(
publisher.local_queue[0][2]['args']['data'][0]['source'],
'test-976')
self.assertEqual(
publisher.local_queue[1023][2]['args']['data'][0]['source'],
'test-1999')
def test_published_with_policy_sized_queue_and_rpc_down(self):
self.rpc_unreachable = True
publisher = rpc.RPCPublisher(
network_utils.urlsplit('rpc://?policy=queue&max_queue_length=3'))
for i in range(5):
for s in self.test_data:
s.source = 'test-%d' % i
publisher.publish_samples(None, self.test_data)
self.assertEqual(len(self.published), 0)
self.assertEqual(len(publisher.local_queue), 3)
self.assertEqual(
publisher.local_queue[0][2]['args']['data'][0]['source'], 'test-2')
self.assertEqual(
publisher.local_queue[1][2]['args']['data'][0]['source'], 'test-3')
self.assertEqual(
publisher.local_queue[2][2]['args']['data'][0]['source'], 'test-4')
def test_published_with_per_meter_topic(self):
publisher = rpc.RPCPublisher(
network_utils.urlsplit('rpc://?per_meter_topic=1'))
publisher.publish_samples(None, self.test_data)
self.assertEqual(len(self.published), 4)
for topic, rpc_call in self.published:
meters = rpc_call['args']['data']
self.assertIsInstance(meters, list)
if topic != self.CONF.publisher_rpc.metering_topic:
self.assertEqual(
len(set(meter['counter_name'] for meter in meters)), 1,
"Meter are published grouped by name")
topics = [topic for topic, meter in self.published]
self.assertIn(self.CONF.publisher_rpc.metering_topic, topics)
self.assertIn(self.CONF.publisher_rpc.metering_topic + '.' + 'test',
topics)
self.assertIn(self.CONF.publisher_rpc.metering_topic + '.' + 'test2',
topics)
self.assertIn(self.CONF.publisher_rpc.metering_topic + '.' + 'test3',
topics)
def test_published_no_mock(self):
publisher = rpc.RPCPublisher(network_utils.urlsplit('rpc://'))
endpoint = mock.MagicMock(['record_metering_data'])
collector = messaging.get_rpc_server(
self.transport, self.CONF.publisher_rpc.metering_topic, endpoint)
endpoint.record_metering_data.side_effect = (
lambda *args, **kwds: collector.stop())
collector.start()
eventlet.sleep()
publisher.publish_samples(context.RequestContext(), self.test_data)
collector.wait()
class Matcher(object):
@staticmethod
def __eq__(data):
for i, sample_item in enumerate(data):
if sample_item['counter_name'] != self.test_data[i].name:
return False
return True
endpoint.record_metering_data.assert_called_once_with(mock.ANY,
data=Matcher())
def test_published_with_policy_queue_and_rpc_down_up(self):
self.rpc_unreachable = True
publisher = rpc.RPCPublisher(
network_utils.urlsplit('rpc://?policy=queue'))
side_effect = oslo.messaging._drivers.common.RPCException()
with mock.patch.object(publisher.rpc_client, 'prepare') as prepare:
prepare.side_effect = side_effect
publisher.publish_samples(mock.MagicMock(), self.test_data)
self.assertEqual(1, len(publisher.local_queue))
prepare.side_effect = mock.MagicMock()
publisher.publish_samples(mock.MagicMock(), self.test_data)
self.assertEqual(0, len(publisher.local_queue))
topic = self.CONF.publisher_rpc.metering_topic
expected = [
mock.call(topic=topic),
mock.call(topic=topic),
mock.call(topic=topic)
]
self.assertEqual(expected, prepare.mock_calls)
def setUp(self):
super(TestPublish, self).setUp()
self.published = []
self.stubs.Set(oslo_rpc, 'cast', self.faux_cast)
publisher = rpc.RPCPublisher(None)
publisher.publish_counters(None, self.test_data, 'test')
