def test_insert(self):
database = Database()
self.assertEqual(len(database.database), 0)
database.insert("CO:12:Hello")
database.insert("CO:11:Hello")
self.assertEqual(len(database.database), 2)
def test_get(self):
database = Database()
message = "CO:12:Hello"
database.insert(message)
entry = database.get("12")
self.assertEqual(entry, message)
def test_update(self):
database = Database()
message = "CO:12:Hello"
database.insert(message)
new_message = "CO:12:Hey"
database.update(new_message)
entry = database.get("12")
self.assertEqual(entry, new_message)
def test_get_duplicate(self):
database = Database()
message_1 = "CO:12:Hello"
database.insert(message_1)
message_2 = "CO:12:Hey"
database.insert(message_2)
entry = database.get("12")
self.assertEqual(len(database.database), 1)
self.assertEqual(entry, message_2)
def test_count(self):
database = Database()
message_1 = "CO:12:Hello"
message_2 = "CO:13:Hey"
message_3 = "CO:14:Hi"
database.insert(message_1)
database.insert(message_2)
database.insert(message_3)
count = database.count()
self.assertEqual(count, 3)
def test_range_start(self):
database = Database()
message_1 = "CO:12:Hello"
message_2 = "CO:13:Hey"
message_3 = "CO:14:Hi"
message_4 = "CO:15:Holla"
database.insert(message_1)
database.insert(message_2)
database.insert(message_3)
database.insert(message_4)
ranges = database.get_range(start=-10)
self.assertEqual(len(ranges), 4)
def __init__(self, frontend=None):
self.threads = []
if frontend is None:
self.frontend = config["frontend_server"]
else:
self.frontend = frontend
self.running = True
self.isActive = False
logging.info("manager started!")
# init socket connections
self.socket_sender = SocketSender()
self.own_address = utils.get_host_address()
# init Ring
self.hosts = Ring(self.own_address)
# init service announcement object
self.service_announcement = ServiceAnnouncement(
self.hosts, self.socket_sender)
# init election
self.election = Election(self.socket_sender,
self.hosts,
frontend=frontend)
# init database
self.database = Database()
# init ReliableSocketWorker
self.reliable_socket = ReliableSocketWorker(
self.running, self.hosts, port=config["reliable_socket"])
try:
self.reliable_socket.run()
self.heartbeat = Heartbeat(self.hosts, self.election,
self.socket_sender)
# initiate service discovery thread
self.discovery_thread = ServiceDiscovery(
self.service_announcement,
self.hosts,
self.election,
self.heartbeat,
self.isActive,
)
self.discovery_thread.start()
self.threads.append(self.discovery_thread)
# start service announcement after discovery
self.service_announcement.announce_service(
timeout=config["announcement_timeout"])
# start election after discovery
self.election.start_election(await_response=True, timeout=1)
self.discovery_thread.isActive = True
# initiate Content Provider
content_provider = ContentProvider(self.election,
self.reliable_socket,
self.database)
content_provider.start()
self.threads.append(content_provider)
# monitor threads and exit on failing
while self.running:
for th in self.threads:
if not th.is_alive():
logging.info("Thread %s died." % th.__class__.__name__)
self.running = False
break
time.sleep(0.2)
except KeyboardInterrupt:
logging.info("Process terminated by user")
except Exception as e:
logging.error("Error in run.py: %s" % e)
traceback.print_exc()
finally:
# graceful shutdown
self.isActive = False
self.discovery_thread.isActive = False
logging.info("stopping threads...")
for th in self.threads:
logging.info("Stopping thread %s." % th.__class__.__name__)
th.stop()
for th in self.threads:
logging.info("Joining thread %s." % th.__class__.__name__)
th.join()
for thread in self.reliable_socket.threads:
logging.info("Joining Thread %s." % thread.name)
thread.join(0.2)
main_thread = threading.currentThread()
for t in threading.enumerate():
if t is main_thread:
continue
logging.info("Joining Thread %s." % thread.name)
t.join(0.2)
logging.info("threads stopped")