init commit

.gitignore

+__pycache__/
\ No newline at end of file

client_register.py

+import socket
+import csv
+
+registered_server = None
+
+def register(port, message_type, message_group):
+
+    PORT = port
+    MSG = bytes(message_type + '_' + message_group, 'utf-8')
+
+    broadcast_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    broadcast_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+
+    broadcast_socket.sendto(MSG, ('<broadcast>', PORT))
+    data, server = broadcast_socket.recvfrom(1024)
+    print('Received message from server: ', data.decode('utf-8'))   
+    
+    data, server = broadcast_socket.recvfrom(1024)
+    print('Received message from server: ', data.decode())
+    
+    registered_server = server
+    print("my server: ", registered_server)
+
+
+
+
+if __name__ == '__main__':
+    action = input("Enter type of action:")
+    print(action)
+    if (action == "r"):
+        group = input("Which group?")
+        register(5970, "register", group)
+    else: 
+        message = input("Enter message:")
+        print(message)
+        

main.py

+import threading
+from server import Server
+import time
+
+if __name__ == '__main__':
+
+    client_address = ""
+    server_id = "MAIN"
+    server_port = 1000
+    server_cache = dict()
+    clients_cache = dict()
+    server = Server(client_address, server_id, server_port, server_cache, clients_cache)
+    time.sleep(10)
+
+

server.py

+import multiprocessing
+import socket
+import threading
+import json
+
+class Server(multiprocessing.Process):
+    server_address = '127.0.0.1'
+    client_cache_key_offset = 0
+    local_servers_cache = dict()
+    local_clients_cache = dict()
+
+    def __init__(self, client_address, server_id, server_port, server_cache, clients_cache):
+        super(Server, self).__init__()
+        self.client_address = client_address
+        self.server_id = server_id
+        self.server_port = server_port
+        self.local_servers_cache = server_cache
+        self.local_clients_cache = clients_cache
+        self.run( )
+
+    def run(self):
+        print("up and running")
+        print("SERVER", self.server_id)
+        if self.server_id == "MAIN":
+            client_listener_thread = threading.Thread(target=self.listen_for_clients)
+            client_listener_thread.start()
+
+        else:
+            cache_update_listener_thread = threading.Thread(target=self.listen_for_cache_update)
+            cache_update_listener_thread.start()
+
+
+    def send_reply_to_client(self):
+        message = 'Hi ' + self.client_address[0] + '. This is server ' + self.server_id
+        server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        server_socket.connect((self.server_address, self.server_port))
+        server_socket.sendto(str.encode(message), self.client_address)
+        server_socket.close()
+
+    def listen_for_clients(self):
+        if self.server_id == "MAIN":
+            BROADCAST_PORT = 5970
+
+            # Local host information
+            MY_HOST = socket.gethostname()
+            MY_IP = socket.gethostbyname(MY_HOST)
+
+            # Create a UDP socket
+            listen_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            # Set the socket to broadcast and enable reusing addresses
+            listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+            listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            # Bind socket to address and port
+            listen_socket.bind((MY_IP, BROADCAST_PORT))
+
+            print("Listening to broadcast messages")
+
+            while True:
+                data, addr = listen_socket.recvfrom(1024)
+                if data:
+                    message = data.decode('utf-8')
+                    print("Received broadcast message:", message)
+                    splitted = message.split("_")
+                    if (splitted[0] == 'register'):
+                        self.register_client(splitted[1], addr)
+  
+                        update_cache_thread = threading.Thread(target=self.updateCacheList)
+                        if update_cache_thread.is_alive:
+                            update_cache_thread.run()
+                        else:
+                            update_cache_thread.start()
+                        
+    
+    # Register client. Check if group already exists. If true, add client to existing list, otherwise create new server.    
+    def register_client(self, group, addr):
+        if group not in self.local_servers_cache:
+            print("group doesn't exist yet. Creating group..")
+            server_adress = self.create_server(group, addr) 
+            
+            self.local_servers_cache[group] = server_adress
+            self.client_cache_key_offset = self.client_cache_key_offset + 1
+            client_cache_key = group + str(self.client_cache_key_offset)
+            self.local_clients_cache[client_cache_key] = addr
+    
+        else:
+            print("group already exists")
+            print(self.client_cache_key_offset)
+            self.client_cache_key_offset = self.client_cache_key_offset + 1
+            client_cache_key = group + str(self.client_cache_key_offset)
+            self.local_clients_cache[client_cache_key] = addr
+        
+        # Create and run new server 
+    def create_server(self, server_id, client_address):
+        # Bind the socket to the port    
+        self.server_port = self.server_port + 1
+
+        new_server = Server(client_address, server_id, self.server_port, self.local_servers_cache, self.local_clients_cache)
+
+        new_server.send_reply_to_client()
+
+        return self.server_port
+        
+    
+    def updateCacheList(self):
+        PORT = 5980
+        servers_cache_as_string = json.dumps(self.local_servers_cache, indent=2).encode('utf-8')
+        clients_cache_as_string = json.dumps(self.local_clients_cache, indent=2).encode('utf-8')
+        separator = "_"
+
+        MSG = servers_cache_as_string + separator.encode('utf-8') + clients_cache_as_string
+
+        broadcast_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        broadcast_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+
+        broadcast_socket.sendto(MSG, ('<broadcast>', PORT))
+        broadcast_socket.close()
+
+    def listen_for_cache_update(self):
+        BROADCAST_PORT = 5980
+
+        # Local host information
+        MY_HOST = socket.gethostname()
+        MY_IP = socket.gethostbyname(MY_HOST)
+
+        # Create a UDP socket
+        listen_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        # Set the socket to broadcast and enable reusing addresses
+        listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+        listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        # Bind socket to address and port
+        listen_socket.bind((MY_IP, BROADCAST_PORT))
+
+        print("Listening to broadcast messages")
+
+        while True:
+            data, addr = listen_socket.recvfrom(1024)
+            if data:
+                message = data.decode('utf-8')
+                print("Received broadcast message:")
+                splitted = message.split("_")
+                server_cache_json = json.loads(splitted[0])
+                client_cache_json = json.loads(splitted[1])
+                self.local_servers_cache = server_cache_json
+                self.local_clients_cache = client_cache_json
+
+                print(self.local_clients_cache)
+
+