communicator requests api implementation done

app.py

@@ -1,12 +1,16 @@
 #!/usr/bin/env python
+import random
+import time
+import uuid
+import logging
 import sentry_sdk
-import communicator
-import consumerlocator
-import messagesender
+from communicator import Communicator
+from consumerlocator import ConsumerLocator
+from messagesender import MessageSender
 
 
 """
-Main Flask RESTful API
+Main entrypoint
 """
 
 __author__ = "@tormakris"
@@ -16,20 +20,18 @@ __version__text__ = "1"
 
 sentry_sdk.init("https://3fa5ae886ba1489092ad49a93cb419c1@sentry.kmlabz.com/9")
 
+logging.basicConfig(level=logging.INFO)
+LOGGER = logging.getLogger(__name__)
+
 if __name__ == "__main__":
-    print("Producer: init")
-    comm = communicator.Communicator()
-    conslist = consumerlocator.ConsumerLocator()
-    conslist.initCommunicator(comm)
-    message = messagesender.MessageSender()
+    LOGGER.info("Producer started")
+    generateduuid = str(uuid)
+    LOGGER.debug(f"My uuid is {generateduuid}")
+    consumerlocator = ConsumerLocator()
+    communicator = Communicator(consumerlocator=consumerlocator,uuid=uuid)
+    messagesender = MessageSender(communicator=communicator)
 
-    conslist.learnconsumerlist()
-    print("Producer: started sending")
-    for i in range(30):
-        print("Producer: send %i message", i)
-        msg = message.CreateMessage(20)
-        if not conslist.checkcurrentconsumer():
-            conslist.updateconsumer()
-        comm.sendmessage(msg)
-
-    print("Producer: finished")
+    while True:
+        LOGGER.info("Sending message to consumer")
+        messagesender.sendmessage()
+        time.sleep(random.random())

communicator.py

@@ -1,8 +1,8 @@
 #!/usr/bin/env python
-
+import logging
 import random
 import requests
-from singleton import Singleton
+from consumerlocator import ConsumerLocator
 
 """
 Communicator module
@@ -13,32 +13,54 @@ __copyright__ = "Copyright 2020, GoldenPogácsa Team"
 __module_name__ = "messagesender"
 __version__text__ = "1"
 
-class Communicator(Singleton):
+logging.basicConfig(level=logging.INFO)
+LOGGER = logging.getLogger(__name__)
+
+class Communicator:
     """
     Class handling low level communication with consumers.
     """
 
+    def __init__(self, consumerlocator: ConsumerLocator, uuid):
+        """
+        Initialize object
+        :param consumerlocator:
+        :param uuid:
+        """
+        self.consumerlocator=consumerlocator
+        self.uuid = uuid
+
     def sendmessage(self, message: str) -> None:
         """
         Send message to consumer.
         :param message:
         :return: none
         """
-        return None
+        currentconsumer=self.consumerlocator.getcurrentconsumer()
+        LOGGER.debug(f"Sending message to {currentconsumer}")
+        requests.post(f'http://{currentconsumer}/log', json={'uuid': self.uuid, 'message': message})
 
     def discoveravailableconsumers(self) -> list:
         """
         Get the list of available consumer from the current primary consumer.
         :return:
         """
-        return ["10.69.42.1","10.42.69.1","10.10.10.10","10.6.66.1"]
+        currentconsumer = self.consumerlocator.getcurrentconsumer()
+        response = requests.get(f'http://{currentconsumer}/consumer')
+        json = response.json()
+        LOGGER.debug(f"List of currently available consumers: {json}")
+        return json
 
     def isconsumeravailable(self) -> bool:
         """
         Readiness probe primary consumer.
         :return:
         """
-        return bool(random.getrandbits(1))
+        currentconsumer = self.consumerlocator.getcurrentconsumer()
+        response = requests.get(f'http://{currentconsumer}/consumer')
+        isavailable = response.status_code == 200
+        LOGGER.debug(f"Current consumer availability: {isavailable}")
+        return isavailable
 
     def checkconsumer(self, consumer: str) -> bool:
         """
@@ -46,4 +68,7 @@ class Communicator(Singleton):
         :param consumer:
         :return:
         """
-        return bool(random.getrandbits(1))
+        response = requests.get(f'http://{consumer}/consumer')
+        isavailable = response.status_code == 200
+        LOGGER.debug(f"Consumer {consumer} availability: {isavailable}")
+        return isavailable

messagesender.py

@@ -1,48 +1,46 @@
 #!/usr/bin/env python
-
+import logging
 import random
 import string
+from communicator import Communicator
 
 """
-Main Flask RESTful API
+Message sender component
 """
 
-__author__ = "@tormakris"
+__author__ = "@kovacsbence"
 __copyright__ = "Copyright 2020, GoldenPogácsa Team"
 __module_name__ = "messagesender"
 __version__text__ = "1"
 
+logging.basicConfig(level=logging.INFO)
+LOGGER = logging.getLogger(__name__)
+
+
 class MessageSender:
     """
     Üzenetek küldéséért felelős komponens.
     """
 
-    def __init__(self):
+    def __init__(self, communicator: Communicator):
         """
         Inicializálja az osztályt.
         """
-        pass
+        self.communicator = communicator
 
-
-    def randomString(self, stringLength):
+    def randomstring(self, stringLength) -> str:
         """Generate a random string of fixed length """
         letters = string.ascii_lowercase
         return ''.join(random.choice(letters) for i in range(stringLength))
 
-
-    def createMessage(self, p) -> str:
+    def sendmessage(self, message: str = "") -> None:
         """
-        Ez egy metodus
-        :param szam:
-        :param szoveg:
+        Uzenet letrehozasa
+        :param message:
         :return: str tipus
         """
-        data = self.randomString(p)
-
-        return str(data)
-        pass
-
-
-if __name__ == "__main__":
-    temp = MessageSender()
-    print(temp.createMessage(20))
+        if not message:
+            data = self.randomstring(32)
+        else:
+            data = message
+        self.communicator.sendmessage(data)

singleton.py

@@ -1,30 +0,0 @@
-#!/usr/bin/env python
-
-"""
-Singleton meta module
-"""
-
-__author__ = "@tormakris"
-__copyright__ = "Copyright 2020, GoldenPogácsa Team"
-__module_name__ = "singleton"
-__version__text__ = "1"
-
-
-class Singleton(object):
-    """
-    Singleton metaclass
-    """
-    _instances = {}
-
-    def __new__(class_, *args, **kwargs):
-        """
-        New
-        :param args:
-        :param kwargs:
-        :return:
-        """
-        if class_ not in class_._instances:
-            class_._instances[class_] = super(
-                Singleton, class_).__new__(
-                class_, *args, **kwargs)
-        return class_._instances[class_]