GoldenPogacsa/producer
GoldenPogacsa/producer
Archived
7
0
Fork 0
Code Issues Pull Requests Releases Activity

add consumerinformation

Browse Source
This commit is contained in:
Kocsis Richárd 2020-05-14 20:09:41 +02:00
parent 20a1aa6dfa
commit 6bdcb40220
6 changed files with 142 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
app.py
View File

@ -10,6 +10,7 @@ import uuid
import logging import logging
import sentry_sdk import sentry_sdk
import time import time
from consumerinformation import ConsumerInformation
from communicator import Communicator from communicator import Communicator
from consumerlocator import ConsumerLocator from consumerlocator import ConsumerLocator
from messagesender import MessageSender from messagesender import MessageSender
@ -42,11 +43,14 @@ if __name__ == "__main__":
""" """
LOGGER.info("Producer started") LOGGER.info("Producer started")
generateduuid = str(uuid.uuid4()) generateduuid = str(uuid.uuid4())
communicator = Communicator(currentconsumer=KNOWNCONSUMER, uuid=generateduuid) redisconnector = RedisConnector()
consumerinfomation = ConsumerInformation(redisconnector=redisconnector)
communicator = Communicator(currentconsumer=KNOWNCONSUMER, uuid=generateduuid,
consumerinformation=consumerinfomation)
LOGGER.debug(f"My uuid is {generateduuid}") LOGGER.debug(f"My uuid is {generateduuid}")
messagesender = MessageSender(communicator=communicator, uuid=generateduuid) messagesender = MessageSender(communicator=communicator, uuid=generateduuid)
consumerlocator = ConsumerLocator(uuid=generateduuid, communicator=communicator, consumerlocator = ConsumerLocator(communicator=communicator,
redisconnector=RedisConnector()) redisconnector=redisconnector)
while True: while True:
consumerlocator.learnconsumerlist() consumerlocator.learnconsumerlist()

37
communicator.py
View File

@ -7,6 +7,7 @@ Communicator module
import logging import logging
import requests import requests
import requests.exceptions import requests.exceptions
from consumerinformation import ConsumerInformation
__author__ = "@tormakris" __author__ = "@tormakris"
__copyright__ = "Copyright 2020, GoldenPogácsa Team" __copyright__ = "Copyright 2020, GoldenPogácsa Team"
@ -22,15 +23,16 @@ class Communicator:
Class handling low level communication with consumers. Class handling low level communication with consumers.
""" """
def __init__(self, currentconsumer: str, uuid: str): def __init__(self, currentconsumer: str, uuid: str, consumerinformation: ConsumerInformation):
"""**Constructor:** """**Constructor:**
Initializes the object. Initializes the object.
:param consumerlocator: the current consumer's IP address as a string :param currentconsumer: the current consumer's IP address as a string
:param uuid: string typed UUID. :param uuid: string typed UUID.
""" """
self.currenctconsumer=currentconsumer self.currenctconsumer = currentconsumer
self.uuid = uuid self.uuid = uuid
self.consumerinformation = consumerinformation
def sendmessage(self, message: str) -> None: def sendmessage(self, message: str) -> None:
"""Send message to the current consumer. Logs the process. """Send message to the current consumer. Logs the process.
@ -38,13 +40,18 @@ class Communicator:
:param message: the message of type string that will be sent. :param message: the message of type string that will be sent.
:return: None :return: None
""" """
currentconsumer=self.currenctconsumer currentconsumer = self.currenctconsumer
LOGGER.info(f"Sending message to {currentconsumer}") LOGGER.info(f"Sending message to {currentconsumer}")
try:
postresponse=requests.post(f'http://{currentconsumer}/log', json={'uuid': self.uuid, 'message': message}, timeout=5) for consumer in self.consumerinformation.getconsumerlist():
LOGGER.debug(f"Message status code is:{postresponse.status_code}") try:
except (requests.exceptions.Timeout, requests.exceptions.ConnectionError) as e: postresponse = requests.post(f'http://{consumer}/log', json={'uuid': self.uuid, 'message': message},
LOGGER.exception(e) # Fun fact: ez azt jelenti, hogy elveszett az üzenet... ide valami retry kellene inkább más consumerek felé... timeout=5)
LOGGER.debug(f"Message status code is:{postresponse.status_code}")
if postresponse.status_code < 300:
return None
except (requests.exceptions.Timeout, requests.exceptions.ConnectionError) as e:
LOGGER.warning(f"Could not send message to {consumer}")
def discoveravailableconsumers(self) -> list: def discoveravailableconsumers(self) -> list:
"""Get the list of available consumer from the current primary consumer. Logs the received list. """Get the list of available consumer from the current primary consumer. Logs the received list.
@ -58,8 +65,8 @@ class Communicator:
LOGGER.info(f"List of currently available consumers: {json}") LOGGER.info(f"List of currently available consumers: {json}")
return json return json
except Exception as e: except Exception as e:
LOGGER.error("Could not query available consumer list!") LOGGER.warning("Could not query available consumer list!")
#LOGGER.exception(e) # LOGGER.exception(e)
return [] return []
def isconsumeravailable(self) -> bool: def isconsumeravailable(self) -> bool:
@ -72,7 +79,7 @@ class Communicator:
response = requests.get(f'http://{currentconsumer}/consumers', timeout=5) response = requests.get(f'http://{currentconsumer}/consumers', timeout=5)
isavailable = response.status_code == 200 isavailable = response.status_code == 200
except Exception as e: except Exception as e:
#LOGGER.exception(e) # LOGGER.exception(e)
isavailable = False isavailable = False
LOGGER.info(f"Current consumer availability: {isavailable}") LOGGER.info(f"Current consumer availability: {isavailable}")
return isavailable return isavailable
@ -87,15 +94,15 @@ class Communicator:
response = requests.get(f'http://{consumer}/consumers', timeout=5) response = requests.get(f'http://{consumer}/consumers', timeout=5)
isavailable = response.status_code == 200 isavailable = response.status_code == 200
except Exception as e: except Exception as e:
#LOGGER.exception(e) # LOGGER.exception(e)
isavailable = False isavailable = False
LOGGER.info(f"Consumer {consumer} availability: {isavailable}") LOGGER.info(f"Consumer {consumer} availability: {isavailable}")
return isavailable return isavailable
def set_currentconsumer(self,currenctconsumer) -> None: def set_currentconsumer(self, currenctconsumer) -> None:
"""Set current consumer """Set current consumer
:param currenctconsumer: the consumer's IP address :param currenctconsumer: the consumer's IP address
:return: None :return: None
""" """
self.currenctconsumer=currenctconsumer self.currenctconsumer = currenctconsumer

37
consumerinformation.py Normal file
View File

@ -0,0 +1,37 @@
#!/usr/bin/env python
"""
Consumer locator module, that manages the list of consumers.
"""
from redisconnector import RedisConnector
__author__ = "@ricsik52"
__copyright__ = "Copyright 2020, GoldenPogácsa Team"
__module_name__ = "consumerlocator"
__version__text__ = "1"
class ConsumerInformation:
"""
Component responsible for providing high level information about consumers
"""
def __init__(self, redisconnector: RedisConnector):
"""**Constructor:**
Initializes the object.
:param redisconnector: the :class:'redisconnector.RedisConnector' instance that will be used for Redis connection.
"""
self.red = redisconnector
def getconsumerlist(self) -> list:
"""
Gets the list of currently available consumers.
:return:
"""
toreturn = []
for consumer in self.red.consumerlist:
if consumer['State']:
toreturn.append(consumer['Host'])
return toreturn

11
consumerlocator.py
View File

@ -20,18 +20,16 @@ LOGGER = logging.getLogger(__name__)
class ConsumerLocator: class ConsumerLocator:
""" """
Component responsible for managing the list of consumers. Requires an instance of :class:`communicator.Communicator` Component responsible for managing the list of consumers. Requires an instance of :class:`communicator.Communicator`
""" """
def __init__(self, uuid: str, communicator: Communicator, redisconnector: RedisConnector): def __init__(self, communicator: Communicator, redisconnector: RedisConnector):
"""**Constructor:** """**Constructor:**
Initializes the object. Initializes the object.
Gets the known consumer's IP address from the PRODUCER_KNOWNCONSUMER envar. Gets the known consumer's IP address from the PRODUCER_KNOWNCONSUMER envar.
:param uuid: Not used
:param communicator: the :class:'communicator.Communicator' instance that will be used for the low level communication. :param communicator: the :class:'communicator.Communicator' instance that will be used for the low level communication.
""" """
self.red = redisconnector self.red = redisconnector
@ -51,7 +49,6 @@ class ConsumerLocator:
if not recievedconsumerlist: if not recievedconsumerlist:
return return
consumer_list = self.red.consumerlist consumer_list = self.red.consumerlist
for recconsumer in recievedconsumerlist: for recconsumer in recievedconsumerlist:
@ -62,7 +59,8 @@ class ConsumerLocator:
if not contains: if not contains:
LOGGER.info(f"Learned about new consumer at {recconsumer}") LOGGER.info(f"Learned about new consumer at {recconsumer}")
consumer_list.append({"Host": recconsumer, "State": True, "LastOk": datetime.datetime.now().timestamp()}) consumer_list.append(
{"Host": recconsumer, "State": True, "LastOk": datetime.datetime.now().timestamp()})
self.red.consumerlist = consumer_list self.red.consumerlist = consumer_list
self.updateconsumerlist() self.updateconsumerlist()
@ -81,7 +79,8 @@ class ConsumerLocator:
for consumer in consumer_list: for consumer in consumer_list:
if not self.communicator.checkconsumer(consumer["Host"]): if not self.communicator.checkconsumer(consumer["Host"]):
consumer["State"] = False consumer["State"] = False
if datetime.datetime.now() - datetime.datetime.fromtimestamp(consumer["LastOk"]) > datetime.timedelta(hours=1): if datetime.datetime.now() - datetime.datetime.fromtimestamp(consumer["LastOk"]) > datetime.timedelta(
hours=1):
removelist.append(consumer) removelist.append(consumer)
else: else:
consumer["LastOk"] = datetime.datetime.now().timestamp() consumer["LastOk"] = datetime.datetime.now().timestamp()

14
integtest.py
View File

@ -4,9 +4,8 @@
Integration test for the producer module. Integration test for the producer module.
""" """
import os
import re import re
import datetime from consumerinformation import ConsumerInformation
from communicator import Communicator from communicator import Communicator
from consumerlocator import ConsumerLocator from consumerlocator import ConsumerLocator
from messagesender import MessageSender from messagesender import MessageSender
@ -23,11 +22,14 @@ redis_proc = factories.redis_proc(host='cache', port=6379)
redis_db = factories.redisdb('redis_nooproc') redis_db = factories.redisdb('redis_nooproc')
answer = "" answer = ""
def answermethod(Request): def answermethod(Request):
global answer global answer
answer = Request answer = Request
return "" return ""
def test_integration(httpserver): def test_integration(httpserver):
""" """
Tests the whole system. Tests the whole system.
@ -45,12 +47,14 @@ def test_integration(httpserver):
method='POST').respond_with_handler(answermethod) method='POST').respond_with_handler(answermethod)
url = httpserver.url_for("/") url = httpserver.url_for("/")
port = re.match(r"\W*http[^:]*\D*(\d+)", url).group(1) port = re.match(r"\W*http[^:]*\D*(\d+)", url).group(1)
redisconnector = RedisConnector()
consumerinfomation = ConsumerInformation(redisconnector=redisconnector)
comm = Communicator( comm = Communicator(
currentconsumer=f"127.0.0.1:{port}", currentconsumer=f"127.0.0.1:{port}",
uuid=generateduuid) uuid=generateduuid, consumerinformation=consumerinfomation)
messagesender = MessageSender(communicator=comm, uuid=generateduuid) messagesender = MessageSender(communicator=comm, uuid=generateduuid)
consumerlocator = ConsumerLocator(uuid=generateduuid, communicator=comm, consumerlocator = ConsumerLocator(communicator=comm,
redisconnector=RedisConnector()) redisconnector=redisconnector)
#First test method #First test method
consumerlocator.learnconsumerlist() consumerlocator.learnconsumerlist()
conslist = consumerlocator.red.consumerlist conslist = consumerlocator.red.consumerlist

82
test.py
View File

@ -9,6 +9,7 @@ import consumerlocator
import communicator import communicator
import messagesender import messagesender
import redisconnector import redisconnector
import consumerinformation
from pytest_redis import factories from pytest_redis import factories
__author__ = "@tormakris" __author__ = "@tormakris"
@ -28,9 +29,11 @@ def test_generate_string(mocker):
:param mocker: patches the :class:`communicator.Communicator`. :param mocker: patches the :class:`communicator.Communicator`.
""" """
mocker.patch('communicator.Communicator') mocker.patch('communicator.Communicator')
redisconnect = redisconnector.RedisConnector()
consumerinfo = consumerinformation.ConsumerInformation(redisconnector=redisconnect)
comm = communicator.Communicator( comm = communicator.Communicator(
currentconsumer="localhost", currentconsumer="localhost",
uuid=generateduuid) uuid=generateduuid, consumerinformation=consumerinfo)
mess = messagesender.MessageSender(communicator=comm, uuid=generateduuid) mess = messagesender.MessageSender(communicator=comm, uuid=generateduuid)
msg = mess.randomstring(stringlength=32) msg = mess.randomstring(stringlength=32)
assert isinstance(msg, str) assert isinstance(msg, str)
@ -52,9 +55,13 @@ def test_sendmessage(httpserver):
"test": "ok"}) "test": "ok"})
url = httpserver.url_for("/") url = httpserver.url_for("/")
port = re.match(r"\W*http[^:]*\D*(\d+)", url).group(1) port = re.match(r"\W*http[^:]*\D*(\d+)", url).group(1)
redisconnect = redisconnector.RedisConnector()
consumerinfo = consumerinformation.ConsumerInformation(redisconnector=redisconnect)
redisconnect.currentconsumer = {"Host": f"127.0.0.1:{port}", "State": True, "LastOk": "1589479202"}
redisconnect.consumerlist = [{"Host": f"127.0.0.1:{port}", "State": True, "LastOk": "1589479202"}]
comm = communicator.Communicator( comm = communicator.Communicator(
currentconsumer=f"127.0.0.1:{port}", currentconsumer=f"127.0.0.1:{port}",
uuid=generateduuid) uuid=generateduuid, consumerinformation=consumerinfo)
mess = "SENDING" mess = "SENDING"
ret = comm.sendmessage(message=mess) ret = comm.sendmessage(message=mess)
assert ret is None assert ret is None
@ -68,9 +75,13 @@ def test_send_message(mocker):
:return: None :return: None
""" """
mocker.patch('communicator.Communicator') mocker.patch('communicator.Communicator')
redisconnect = redisconnector.RedisConnector()
consumerinfo = consumerinformation.ConsumerInformation(redisconnector=redisconnect)
redisconnect.currentconsumer = {"Host": f"127.0.0.1", "State": True, "LastOk": "1589479202"}
redisconnect.consumerlist = [{"Host": f"127.0.0.1", "State": True, "LastOk": "1589479202"}]
comm = communicator.Communicator( comm = communicator.Communicator(
currentconsumer="127.0.0.1", currentconsumer="127.0.0.1",
uuid=generateduuid) uuid=generateduuid, consumerinformation=consumerinfo)
mess = messagesender.MessageSender(communicator=comm, uuid=generateduuid) mess = messagesender.MessageSender(communicator=comm, uuid=generateduuid)
messa = "SENDING" messa = "SENDING"
msg = mess.sendmessage(message=messa) msg = mess.sendmessage(message=messa)
@ -91,9 +102,13 @@ def test_discoveravailableconsumers(httpserver):
["10.69.42.1", "10.10.10.10", "10.20.30.40"]) ["10.69.42.1", "10.10.10.10", "10.20.30.40"])
url = httpserver.url_for("/") url = httpserver.url_for("/")
port = re.match(r"\W*http[^:]*\D*(\d+)", url).group(1) port = re.match(r"\W*http[^:]*\D*(\d+)", url).group(1)
redisconnect = redisconnector.RedisConnector()
consumerinfo = consumerinformation.ConsumerInformation(redisconnector=redisconnect)
redisconnect.currentconsumer = {"Host": f"127.0.0.1:{port}", "State": True, "LastOk": "1589479202"}
redisconnect.consumerlist = [{"Host": f"127.0.0.1:{port}", "State": True, "LastOk": "1589479202"}]
comm = communicator.Communicator( comm = communicator.Communicator(
currentconsumer=f"127.0.0.1:{port}", currentconsumer=f"127.0.0.1:{port}",
uuid=generateduuid) uuid=generateduuid, consumerinformation=consumerinfo)
ret = comm.discoveravailableconsumers() ret = comm.discoveravailableconsumers()
assert isinstance(ret, list) assert isinstance(ret, list)
assert ret == ["10.69.42.1", "10.10.10.10", "10.20.30.40"] assert ret == ["10.69.42.1", "10.10.10.10", "10.20.30.40"]
@ -113,9 +128,13 @@ def test_isconsumeravailable(httpserver):
["10.69.42.1", "10.10.10.10", "10.20.30.40"]) ["10.69.42.1", "10.10.10.10", "10.20.30.40"])
url = httpserver.url_for("/") url = httpserver.url_for("/")
port = re.match(r"\W*http[^:]*\D*(\d+)", url).group(1) port = re.match(r"\W*http[^:]*\D*(\d+)", url).group(1)
redisconnect = redisconnector.RedisConnector()
consumerinfo = consumerinformation.ConsumerInformation(redisconnector=redisconnect)
redisconnect.currentconsumer = {"Host": f"127.0.0.1:{port}", "State": True, "LastOk": "1589479202"}
redisconnect.consumerlist = [{"Host": f"127.0.0.1:{port}", "State": True, "LastOk": "1589479202"}]
comm = communicator.Communicator( comm = communicator.Communicator(
currentconsumer=f"127.0.0.1:{port}", currentconsumer=f"127.0.0.1:{port}",
uuid=generateduuid) uuid=generateduuid, consumerinformation=consumerinfo)
ret = comm.isconsumeravailable() ret = comm.isconsumeravailable()
assert isinstance(ret, bool) assert isinstance(ret, bool)
assert ret assert ret
@ -126,7 +145,7 @@ def test_isconsumeravailable(httpserver):
comm2 = communicator.Communicator( comm2 = communicator.Communicator(
currentconsumer="127.0.0.1:69", currentconsumer="127.0.0.1:69",
uuid=generateduuid) uuid=generateduuid, consumerinformation=consumerinfo)
ret3 = comm2.isconsumeravailable() ret3 = comm2.isconsumeravailable()
assert isinstance(ret3, bool) assert isinstance(ret3, bool)
@ -147,9 +166,13 @@ def test_checkconsumer(httpserver):
["10.69.42.1", "10.10.10.10", "10.20.30.40"]) ["10.69.42.1", "10.10.10.10", "10.20.30.40"])
url = httpserver.url_for("/") url = httpserver.url_for("/")
port = re.match(r"\W*http[^:]*\D*(\d+)", url).group(1) port = re.match(r"\W*http[^:]*\D*(\d+)", url).group(1)
redisconnect = redisconnector.RedisConnector()
consumerinfo = consumerinformation.ConsumerInformation(redisconnector=redisconnect)
redisconnect.currentconsumer = {"Host": f"127.0.0.1:{port}", "State": True, "LastOk": "1589479202"}
redisconnect.consumerlist = [{"Host": f"127.0.0.1:{port}", "State": True, "LastOk": "1589479202"}]
comm = communicator.Communicator( comm = communicator.Communicator(
currentconsumer="127.0.0.1", currentconsumer="127.0.0.1",
uuid=generateduuid) uuid=generateduuid, consumerinformation=consumerinfo)
ret = comm.checkconsumer(f"127.0.0.1:{port}") ret = comm.checkconsumer(f"127.0.0.1:{port}")
assert isinstance(ret, bool) assert isinstance(ret, bool)
assert ret assert ret
@ -160,8 +183,7 @@ def test_checkconsumer(httpserver):
comm2 = communicator.Communicator( comm2 = communicator.Communicator(
currentconsumer="127.0.0.1", currentconsumer="127.0.0.1",
uuid=generateduuid) uuid=generateduuid, consumerinformation=consumerinfo)
ret3 = comm2.checkconsumer(f"127.0.0.1:{port}") ret3 = comm2.checkconsumer(f"127.0.0.1:{port}")
assert isinstance(ret3, bool) assert isinstance(ret3, bool)
assert ret3 == False assert ret3 == False
@ -173,9 +195,11 @@ def test_setcurrentconsumer():
:return: None :return: None
""" """
redisconnect = redisconnector.RedisConnector()
consumerinfo = consumerinformation.ConsumerInformation(redisconnector=redisconnect)
comm = communicator.Communicator( comm = communicator.Communicator(
currentconsumer="127.0.0.1", currentconsumer="127.0.0.1",
uuid=generateduuid) uuid=generateduuid, consumerinformation=consumerinfo)
comm.set_currentconsumer("10.69.42.1") comm.set_currentconsumer("10.69.42.1")
assert comm.currenctconsumer == "10.69.42.1" assert comm.currenctconsumer == "10.69.42.1"
@ -194,12 +218,16 @@ def test_learnconsumerlist(httpserver):
["10.69.42.1", "10.10.10.10", "10.20.30.40"]) ["10.69.42.1", "10.10.10.10", "10.20.30.40"])
url = httpserver.url_for("/") url = httpserver.url_for("/")
port = re.match(r"\W*http[^:]*\D*(\d+)", url).group(1) port = re.match(r"\W*http[^:]*\D*(\d+)", url).group(1)
redisconnect = redisconnector.RedisConnector()
consumerinfo = consumerinformation.ConsumerInformation(redisconnector=redisconnect)
redisconnect.currentconsumer = {"Host": f"127.0.0.1:{port}", "State": True, "LastOk": "1589479202"}
redisconnect.consumerlist = [{"Host": f"127.0.0.1:{port}", "State": True, "LastOk": "1589479202"}]
comm = communicator.Communicator( comm = communicator.Communicator(
currentconsumer=f"127.0.0.1:{port}", currentconsumer=f"127.0.0.1:{port}",
uuid=generateduuid) uuid=generateduuid, consumerinformation=consumerinfo)
consumerlocator.KNOWNCONSUMER = f"127.0.0.1:{port}" consumerlocator.KNOWNCONSUMER = f"127.0.0.1:{port}"
locator = consumerlocator.ConsumerLocator( locator = consumerlocator.ConsumerLocator(
uuid=generateduuid, communicator=comm, communicator=comm,
redisconnector=redisconnector.RedisConnector()) redisconnector=redisconnector.RedisConnector())
ret = locator.learnconsumerlist() ret = locator.learnconsumerlist()
assert ret is None assert ret is None
@ -213,11 +241,13 @@ def test_getcurrentconsumer(mocker):
:return: None :return: None
""" """
mocker.patch('communicator.Communicator') mocker.patch('communicator.Communicator')
redisconnect = redisconnector.RedisConnector()
consumerinfo = consumerinformation.ConsumerInformation(redisconnector=redisconnect)
comm = communicator.Communicator( comm = communicator.Communicator(
currentconsumer="127.0.0.1", currentconsumer="127.0.0.1",
uuid=generateduuid) uuid=generateduuid, consumerinformation=consumerinfo)
locator = consumerlocator.ConsumerLocator( locator = consumerlocator.ConsumerLocator(
uuid=generateduuid, communicator=comm, communicator=comm,
redisconnector=redisconnector.RedisConnector()) redisconnector=redisconnector.RedisConnector())
assert locator.getcurrentconsumer() == consumerlocator.KNOWNCONSUMER assert locator.getcurrentconsumer() == consumerlocator.KNOWNCONSUMER
@ -236,13 +266,17 @@ def test_checkcurrentconsumer(httpserver):
["10.69.42.1", "10.10.10.10", "10.20.30.40"]) ["10.69.42.1", "10.10.10.10", "10.20.30.40"])
url = httpserver.url_for("/") url = httpserver.url_for("/")
port = re.match(r"\W*http[^:]*\D*(\d+)", url).group(1) port = re.match(r"\W*http[^:]*\D*(\d+)", url).group(1)
redisconnect = redisconnector.RedisConnector()
consumerinfo = consumerinformation.ConsumerInformation(redisconnector=redisconnect)
comm = communicator.Communicator( comm = communicator.Communicator(
currentconsumer=f"127.0.0.1:{port}", currentconsumer=f"127.0.0.1:{port}",
uuid=generateduuid) uuid=generateduuid, consumerinformation=consumerinfo)
consumerlocator.KNOWNCONSUMER = f"127.0.0.1:{port}" consumerlocator.KNOWNCONSUMER = f"127.0.0.1:{port}"
locator = consumerlocator.ConsumerLocator( locator = consumerlocator.ConsumerLocator(
uuid=generateduuid, communicator=comm, communicator=comm,
redisconnector=redisconnector.RedisConnector()) redisconnector=redisconnector.RedisConnector())
redisconnect.currentconsumer = {"Host": f"127.0.0.1:{port}", "State": True, "LastOk": "1589479202"}
redisconnect.consumerlist = [{"Host": f"127.0.0.1:{port}", "State": True, "LastOk": "1589479202"}]
ret = locator.checkcurrentconsumer() ret = locator.checkcurrentconsumer()
assert ret == True assert ret == True
@ -261,14 +295,18 @@ def test_updateconsumer(httpserver):
["10.69.42.1", "10.10.10.10", "10.20.30.40"]) ["10.69.42.1", "10.10.10.10", "10.20.30.40"])
url = httpserver.url_for("/") url = httpserver.url_for("/")
port = re.match(r"\W*http[^:]*\D*(\d+)", url).group(1) port = re.match(r"\W*http[^:]*\D*(\d+)", url).group(1)
redisconnect = redisconnector.RedisConnector()
consumerinfo = consumerinformation.ConsumerInformation(redisconnector=redisconnect)
comm = communicator.Communicator( comm = communicator.Communicator(
currentconsumer=f"127.0.0.1:{port}", currentconsumer=f"127.0.0.1:{port}",
uuid=generateduuid) uuid=generateduuid, consumerinformation=consumerinfo)
consumerlocator.KNOWNCONSUMER = f"127.0.0.1:{port}" consumerlocator.KNOWNCONSUMER = f"127.0.0.1:{port}"
redisconn = redisconnector.RedisConnector() redisconn = redisconnector.RedisConnector()
locator = consumerlocator.ConsumerLocator( locator = consumerlocator.ConsumerLocator(
uuid=generateduuid, communicator=comm, communicator=comm,
redisconnector=redisconn) redisconnector=redisconn)
redisconnect.currentconsumer = {"Host": f"127.0.0.1:{port}", "State": True, "LastOk": "1589479202"}
redisconnect.consumerlist = [{"Host": f"127.0.0.1:{port}", "State": True, "LastOk": "1589479202"}]
assert redisconn.currentconsumer is not None assert redisconn.currentconsumer is not None
ret = locator.updateconsumer() ret = locator.updateconsumer()
assert ret == f"127.0.0.1:{port}" assert ret == f"127.0.0.1:{port}"
@ -288,12 +326,16 @@ def test_updateconsumerlist(httpserver):
["10.69.42.1", "10.10.10.10", "10.20.30.40"]) ["10.69.42.1", "10.10.10.10", "10.20.30.40"])
url = httpserver.url_for("/") url = httpserver.url_for("/")
port = re.match(r"\W*http[^:]*\D*(\d+)", url).group(1) port = re.match(r"\W*http[^:]*\D*(\d+)", url).group(1)
redisconnect = redisconnector.RedisConnector()
consumerinfo = consumerinformation.ConsumerInformation(redisconnector=redisconnect)
comm = communicator.Communicator( comm = communicator.Communicator(
currentconsumer=f"127.0.0.1:{port}", currentconsumer=f"127.0.0.1:{port}",
uuid=generateduuid) uuid=generateduuid, consumerinformation=consumerinfo)
consumerlocator.KNOWNCONSUMER = f"127.0.0.1:{port}" consumerlocator.KNOWNCONSUMER = f"127.0.0.1:{port}"
locator = consumerlocator.ConsumerLocator( locator = consumerlocator.ConsumerLocator(
uuid=generateduuid, communicator=comm, communicator=comm,
redisconnector=redisconnector.RedisConnector()) redisconnector=redisconnector.RedisConnector())
redisconnect.currentconsumer = {"Host": f"127.0.0.1:{port}", "State": True, "LastOk": "1589479202"}
redisconnect.consumerlist = [{"Host": f"127.0.0.1:{port}", "State": True, "LastOk": "1589479202"}]
ret = locator.updateconsumerlist() ret = locator.updateconsumerlist()
assert ret is None assert ret is None