added client class

client.py

+import multiprocessing
+import socket
+import threading
+
+class Client(multiprocessing.Process):
+
+    registered_server = None
+
+    def __init__(self):
+        self.run()
+
+    def run(self):
+        print("Client up and running")
+        action = input("Enter type of action ('r' to register): ")
+        if (action == "r"):
+            group = input("Which group dou you want to join? ")
+            self.register(5970, "register", group)
+
+            send_thread = threading.Thread(target=self.send_message)
+            #receive_thread = threading.Thread(target=receive_messages)
+
+            send_thread.start()
+            #receive_thread.start()
+
+            # waiting for thread to stop = prevent the programm from shutdown before thread is stopped
+            send_thread.join()
+            #receive_thread.join()
+
+        else: 
+            message = input("Enter message:")
+            print(message)
+
+    def register(self, 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'))   
+        
+        self.registered_server = server
+        print("My server: ", self.registered_server)
+
+        broadcast_socket.close()
+
+    def send_message(self):
+
+        while True:
+            message = input()
+            if message.lower() == 'exit':
+                break
+            print(self.registered_server)
+
+            client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            #client_socket.connect((self.server_address, self.server_port))
+            client_socket.sendto(str.encode(message), self.registered_server)
+            client_socket.close()

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)
-
-
+from client import Client
+import time
 
 
 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)
-        
+    client = Client()
+    time.sleep(10)   

server.py

@@ -19,8 +19,8 @@ class Server(multiprocessing.Process):
         self.run( )
 
     def run(self):
-        print("up and running")
-        print("SERVER", self.server_id)
+        print(self.server_id+": "+"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()
@@ -28,10 +28,12 @@ class Server(multiprocessing.Process):
         else:
             cache_update_listener_thread = threading.Thread(target=self.listen_for_cache_update)
             cache_update_listener_thread.start()
+            client_message_listener_thread = threading.Thread(target=self.listen_for_client_messages)
+            client_message_listener_thread.start()
 
 
     def send_reply_to_client(self):
-        message = 'Hi ' + self.client_address[0] + '. This is server ' + self.server_id
+        message = 'Hi ' + self.client_address[0] + ' this is your chat-group 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)
@@ -53,16 +55,16 @@ class Server(multiprocessing.Process):
             # Bind socket to address and port
             listen_socket.bind((MY_IP, BROADCAST_PORT))
 
-            print("Listening to broadcast messages")
+            print(self.server_id+": "+"Listening to client register broadcast messages")
 
             while True:
                 data, addr = listen_socket.recvfrom(1024)
                 if data:
                     message = data.decode('utf-8')
-                    print("Received broadcast message:", message)
+                    print(self.server_id+": "+"Received client register broadcast message:", message)
                     splitted = message.split("_")
                     if (splitted[0] == 'register'):
-                        self.register_client(splitted[1], addr)
+                        self.register_client(splitted[1].upper(), addr)
   
                         update_cache_thread = threading.Thread(target=self.updateCacheList)
                         if update_cache_thread.is_alive:
@@ -74,24 +76,35 @@ class Server(multiprocessing.Process):
     # 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..")
+            print(self.server_id+": "+"Group "+group+" doesn't exist yet. Creating group..")
             server_adress = self.create_server(group, addr) 
             
+            group_count = self.filter_groups(group)
+
             self.local_servers_cache[group] = server_adress
-            self.client_cache_key_offset = self.client_cache_key_offset + 1
+            self.client_cache_key_offset = group_count + 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)
+            print(self.server_id+": "+"Group "+group+" already exists")
             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
 
+     
+    def filter_groups(self, group):
+        group_count = 0
+        for key in self.local_servers_cache:
+            if group in key:
+                group_count = group_count + 1
+        
+        return group_count
+        
     # 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)
@@ -100,7 +113,6 @@ class Server(multiprocessing.Process):
 
         return self.server_port
 
-    
     def updateCacheList(self):
         PORT = 5980
         servers_cache_as_string = json.dumps(self.local_servers_cache, indent=2).encode('utf-8')
@@ -130,19 +142,23 @@ class Server(multiprocessing.Process):
         # Bind socket to address and port
         listen_socket.bind((MY_IP, BROADCAST_PORT))
 
-        print("Listening to broadcast messages")
+        print(self.server_id+": "+"Listening to cache update broadcast messages")
 
         while True:
             data, addr = listen_socket.recvfrom(1024)
             if data:
                 message = data.decode('utf-8')
-                print("Received broadcast message:")
+                print(self.server_id+": "+"Received cache update 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)
+                print("Group View Server: "+self.local_servers_cache)
+                print("Group View Clients: "+self.local_clients_cache)
+
+    def listen_for_client_messages():
 
+        return