def test_multiple_instance(self):
""" Test Clients with no instance """
message_bus_1 = MessageBus()
message_bus_2 = MessageBus()
message_bus_3 = MessageBus()
admin = MessageBusAdmin(admin_id='admin', message_bus=message_bus_1)
self.assertTrue(TestMessage._msg_type in admin.list_message_types())
messages = []
producer = MessageProducer(producer_id='p1', \
message_type=TestMessage._msg_type, method='sync', \
message_bus=message_bus_2)
self.assertIsNotNone(producer, "Producer not found")
for i in range(0, TestMessage._msg_count):
messages.append("This is message" + str(i))
producer.send(messages)
consumer = MessageConsumer(consumer_id='msys', consumer_group='connn', \
message_types=[TestMessage._msg_type], auto_ack=True, \
offset='latest', message_bus=message_bus_3)
count = 0
while True:
try:
message = consumer.receive()
if isinstance(message, bytes):
count += 1
consumer.ack()
except Exception:
self.assertEqual(count, TestMessage._msg_count)
break
def test_same_instance(self):
""" Test Singleton functionality """
message_bus_1 = MessageBus()
message_bus_2 = MessageBus()
# Check for same instance
self.assertEqual(message_bus_1, message_bus_2)
def validate(self):
"""Check for below requirement.
1. Validate input configs
2. Validate sspl conf is created
3. Check if message bus is accessible
"""
if os.geteuid() != 0:
msg = "Run this command with root privileges."
logger.error(msg)
raise SetupError(errno.EINVAL, msg)
# Validate input/provisioner configs
machine_id = Utility.get_machine_id()
Utility.get_config_value(consts.PRVSNR_CONFIG_INDEX,
"server_node>%s>cluster_id" % machine_id)
self.node_type = Utility.get_config_value(
consts.PRVSNR_CONFIG_INDEX, "server_node>%s>type" % machine_id)
enclosure_id = Utility.get_config_value(
consts.PRVSNR_CONFIG_INDEX,
"server_node>%s>storage>enclosure_id" % machine_id)
self.enclosure_type = Utility.get_config_value(
consts.PRVSNR_CONFIG_INDEX,
"storage_enclosure>%s>type" % enclosure_id)
# Validate sspl conf is created
if not os.path.isfile(consts.file_store_config_path):
msg = "Missing configuration - %s !! Create and rerun." % (
consts.file_store_config_path)
logger.error(msg)
raise SetupError(errno.EINVAL, msg)
# Validate message bus is accessible
self.mb = MessageBus()
class TestMessage(unittest.TestCase):
"""Test MessageBus related functionality."""
message_bus = MessageBus()
def test_send(self):
"""Test Send Message."""
messages = []
producer = MessageProducer(TestMessage.message_bus, \
producer_id='sspl_sensor', message_type='Alert')
self.assertIsNotNone(producer, "Producer not found")
for i in range(0, 1000):
messages.append("This is message" + str(i))
self.assertEqual(len(messages), 1000)
self.assertIsInstance(messages, list)
producer.send(messages)
def test_receive(self):
"""Test Receive Message."""
consumer = MessageConsumer(TestMessage.message_bus, \
consumer_id='sspl_sensors', consumer_group='sspl', \
message_types=['Alert'], auto_ack=False, offset='latest')
self.assertIsNotNone(consumer, "Consumer not found")
count = 0
while True:
try:
message = consumer.receive()
count += 1
self.assertIsNotNone(message, "Message not found")
consumer.ack()
except Exception as e:
self.assertEqual(count, 1000)
break
class TestMessage(unittest.TestCase):
""" Test MessageBus related functionality """
message_bus = MessageBus()
def test_send(self):
""" Test Send Message """
messages = []
producer = MessageProducer(TestMessage.message_bus, \
producer_id='p1', message_type='big')
self.assertIsNotNone(producer, "Producer not found")
for i in range(0, 100):
messages.append("This is message" + str(i))
self.assertEqual(len(messages), 100)
self.assertIsInstance(messages, list)
producer.send(messages)
def test_count(self):
""" Test Unread Message Count """
consumer = MessageConsumer(TestMessage.message_bus, \
consumer_id='sensors', consumer_group='test_group', \
message_types=['big'], auto_ack=True, offset='latest')
self.assertIsNotNone(consumer, "Consumer not found")
unread_count = consumer.get_unread_count()
self.assertEqual(unread_count, 100)
def __init__(self, client_type: str, **client_conf: dict):
self._message_bus = MessageBus() if 'message_bus' not in \
client_conf.keys() or client_conf['message_bus'] is None else \
client_conf['message_bus']
self._message_bus.init_client(client_type, **client_conf)
self._client_conf = client_conf
Log.debug(f"MessageBusClient: initialized with arguments" \
f" client_type: {client_type}, kwargs: {client_conf}")
def connect(self):
"""Connect to Message Bus."""
try:
self._message_bus = MessageBus()
except Exception as exception:
msg = ("msg_bus init except:%s %s") % (exception,
traceback.format_exc())
return False, msg
return True, None
def test_send(self):
""" Test Send Message. """
messages = []
message_bus = MessageBus()
producer = MessageProducer(message_bus, producer_id='sel', \
message_type='Sel', method='async')
self.assertIsNotNone(producer, "Producer not found")
for i in range(0, 10):
messages.append("This is message" + str(i))
self.assertIsInstance(messages, list)
producer.send(messages)
def test_receive(self):
""" Test Receive Message. """
message_bus = MessageBus()
consumer = MessageConsumer(message_bus, consumer_id='sel', \
consumer_group='sel', message_type=['Sel'], auto_ack=False, \
offset='latest')
self.assertIsNotNone(consumer, "Consumer not found")
while True:
try:
message = consumer.receive()
self.assertIsNotNone(message, "Message not found")
consumer.ack()
except Exception as e:
break
class TestMessage(unittest.TestCase):
""" Test MessageBus related functionality """
message_bus = MessageBus()
_message_type = 'test_topic'
_partition = 1
def test_list_message_type(self):
""" Test list message type API """
admin = MessageBusAdmin(TestMessage.message_bus, admin_id='admin')
admin.register_message_type(message_types=[TestMessage._message_type], \
partitions=TestMessage._partition)
message_type_list = admin.list_message_types()
self.assertTrue(TestMessage._message_type in message_type_list)
def __init__(self):
from cortx.utils.message_bus import MessageBus
from cortx.utils.conf_store import Conf
Conf.load("index", "json:///etc/cortx/message_bus.conf")
self._server = Conf.get("index", 'message_broker>cluster[0]>server')
self._msg_bus = MessageBus()
# Create a test topic
cmd = "/opt/kafka/bin/kafka-topics.sh --create" + \
" --topic mytest --bootstrap-server " + self._server + ":9092"
try:
cmd_proc = SimpleProcess(cmd)
res_op, res_err, res_rc = cmd_proc.run()
if res_rc != 0:
raise SetupError(errno.EINVAL, "Unable to test the config")
except Exception as e:
raise SetupError(errno.EINVAL, \
"Unable to test the config, %s", e)
class TestMessage(unittest.TestCase):
""" Test MessageBus related functionality. """
message_bus = MessageBus()
def test_consumer_one(self):
""" Test Receive Message for consumer group 1 """
consumer = MessageConsumer(TestMessage.message_bus, \
consumer_id='sspl_sensor', consumer_group='c1', \
message_type=['test_type'], auto_ack=False, offset='latest')
self.assertIsNotNone(consumer, "Consumer not found")
count = 0
while True:
try:
message = consumer.receive()
count += 1
self.assertIsNotNone(message, "Message not found")
consumer.ack()
except Exception as e:
self.assertEqual(count, 10)
break
def test_consumer_two(self):
""" Test Receive Message for consumer group 2 """
consumer = MessageConsumer(TestMessage.message_bus, \
consumer_id='sspl_sensor1', consumer_group='c3', \
message_type=['test_type'], auto_ack=False, offset='latest')
self.assertIsNotNone(consumer, "Consumer not found")
count = 0
while True:
try:
message = consumer.receive()
count += 1
self.assertIsNotNone(message, "Message not found")
consumer.ack()
except Exception as e:
self.assertEqual(count, 10)
break
def create_message_types(self):
# Skip this step if sspl is being configured for node
# replacement scenario as rabbitmq cluster is
# already configured on the healthy node
# Configure rabbitmq
if not os.path.exists(consts.REPLACEMENT_NODE_ENV_VAR_FILE):
message_types = [
Conf.get(consts.SSPL_CONFIG_INDEX, "RABBITMQINGRESSPROCESSOR"
">message_type"),
Conf.get(consts.SSPL_CONFIG_INDEX, "RABBITMQEGRESSPROCESSOR"
">message_type")
]
mb = MessageBus()
mbadmin = MessageBusAdmin(mb, admin_id='admin')
try:
mbadmin.register_message_type(message_types=message_types,
partitions=1)
except MessageBusError as e:
if self.topic_already_exists in e.desc:
# Topic already exists
pass
else:
raise e
def __init__(self,
event_list: List[SubscribeEvent],
group_id: str = COMPONENT_ID):
"""
event_list - list of events to subscribe to.
group_id - the group_id to pass to KafkaConsumer.
"""
logging.debug('Inside EventListener')
self.event_manager = EventManager.get_instance()
topic = self._subscribe(event_list)
if topic is None:
raise RuntimeError('Failed to subscribe to events')
message_bus = MessageBus()
self.consumer = MessageConsumer(
message_bus=message_bus,
consumer_id=COMPONENT_ID,
consumer_group=group_id,
message_types=[topic],
# Why is it 'str' in cortx-py-utils??
auto_ack=str(False),
offset='earliest')
def test_send_invalid_message(self):
"""Send invalid message format."""
message = MessageBus()
with self.assertRaises(MessageBusError):
TestKVPayloadMessage._producer.send([message])
# Copyright (c) 2020 Seagate Technology LLC and/or its Affiliates # # This program is free software: you can redistribute it and/or modify it under the # terms of the GNU Affero General Public License as published by the Free Software # Foundation, either version 3 of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, but WITHOUT ANY # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A # PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. # # You should have received a copy of the GNU Affero General Public License along # with this program. If not, see <https://www.gnu.org/licenses/>. For any questions # about this software or licensing, please email [email protected] or # [email protected]. """Modules for handling rabbitMQ processing""" from threading import Event from cortx.utils.message_bus import MessageBus message_bus = MessageBus() producer_initialized = Event()
def __init__(self, client_type: str, **client_conf: dict):
self._message_bus = MessageBus() if 'message_bus' not in \
client_conf.keys() or client_conf['message_bus'] is None else \
client_conf['message_bus']
self._message_bus.init_client(client_type, **client_conf)
self._client_conf = client_conf
def test_013_singleton(self):
"""Test instance of message_bus."""
message_bus_1 = MessageBus()
message_bus_2 = MessageBus()
self.assertTrue(message_bus_1 is message_bus_2)