Support for mongodb replicaset connection (HA).

[osm/common.git] / osm_common / msgkafka.py

diff --git a/osm_common/msgkafka.py b/osm_common/msgkafka.py
index 63ee69c..4d02024 100644 (file)
--- a/osm_common/msgkafka.py
+++ b/osm_common/msgkafka.py
@@ -64,11 +64,15 @@ class MsgKafka(MsgBase):
         :param msg: message content, can be string or dictionary
         :return: None or raises MsgException on failing
         """
-        try:
-            self.loop.run_until_complete(self.aiowrite(topic=topic, key=key, msg=msg))
-
-        except Exception as e:
-            raise MsgException("Error writing {} topic: {}".format(topic, str(e)))
+        retry = 2   # Try two times
+        while retry:
+            try:
+                self.loop.run_until_complete(self.aiowrite(topic=topic, key=key, msg=msg))
+                break
+            except Exception as e:
+                retry -= 1
+                if retry == 0:
+                    raise MsgException("Error writing {} topic: {}".format(topic, str(e)))
 
     def read(self, topic):
         """
@@ -105,36 +109,47 @@ class MsgKafka(MsgBase):
         finally:
             await self.producer.stop()
 
-    async def aioread(self, topic, loop=None, callback=None, aiocallback=None, **kwargs):
+    async def aioread(self, topic, loop=None, callback=None, aiocallback=None, group_id=None, from_beginning=None,
+                      **kwargs):
         """
         Asyncio read from one or several topics.
         :param topic: can be str: single topic; or str list: several topics
         :param loop: asyncio loop. To be DEPRECATED! in near future!!!  loop must be provided inside config at connect
         :param callback: synchronous callback function that will handle the message in kafka bus
         :param aiocallback: async callback function that will handle the message in kafka bus
+        :param group_id: kafka group_id to use. Can be False (set group_id to None), None (use general group_id provided
+                         at connect inside config), or a group_id string
+        :param from_beginning: if True, messages will be obtained from beginning instead of only new ones.
+                               If group_id is supplied, only the not processed messages by other worker are obtained.
+                               If group_id is None, all messages stored at kafka are obtained.
         :param kwargs: optional keyword arguments for callback function
         :return: If no callback defined, it returns (topic, key, message)
         """
 
         if not loop:
             loop = self.loop
+        if group_id is False:
+            group_id = None
+        elif group_id is None:
+            group_id = self.group_id
         try:
             if isinstance(topic, (list, tuple)):
                 topic_list = topic
             else:
                 topic_list = (topic,)
-
-            self.consumer = AIOKafkaConsumer(loop=loop, bootstrap_servers=self.broker, group_id=self.group_id)
+            self.consumer = AIOKafkaConsumer(loop=loop, bootstrap_servers=self.broker, group_id=group_id,
+                                             auto_offset_reset="earliest" if from_beginning else "latest")
             await self.consumer.start()
             self.consumer.subscribe(topic_list)
 
             async for message in self.consumer:
                 if callback:
-                    callback(message.topic, yaml.load(message.key), yaml.load(message.value), **kwargs)
+                    callback(message.topic, yaml.safe_load(message.key), yaml.safe_load(message.value), **kwargs)
                 elif aiocallback:
-                    await aiocallback(message.topic, yaml.load(message.key), yaml.load(message.value), **kwargs)
+                    await aiocallback(message.topic, yaml.safe_load(message.key), yaml.safe_load(message.value),
+                                      **kwargs)
                 else:
-                    return message.topic, yaml.load(message.key), yaml.load(message.value)
+                    return message.topic, yaml.safe_load(message.key), yaml.safe_load(message.value)
         except KafkaError as e:
             raise MsgException(str(e))
         finally: