diff --git a/2024-11-26_Forming_a_Ring_ohne_Update_Ring-Threading_.py b/2024-11-26_Forming_a_Ring_ohne_Update_Ring-Threading_.py
new file mode 100644
index 0000000000000000000000000000000000000000..129b5aded0d5a47788432be94362941eeddb26cc
--- /dev/null
+++ b/2024-11-26_Forming_a_Ring_ohne_Update_Ring-Threading_.py
@@ -0,0 +1,162 @@
+#Ring testebn
+#Forming a Ring
+
+import time
+import threading
+from uuid import uuid4
+import socket
+import uuid
+import json
+#Neu
+leader = False
+#Definition Atribute
+global members
+members = [] #List for members in the ring
+broadcast_ip = "255.255.255.255" #Broadcast-adress in the Network
+port = 12348 #Port that is used for the discovery of new server participants
+server_ip = "0.0.0.0" #IP that enables the server to receive all messages that are passed to the port
+my_ip = str(uuid.uuid4()) #Creating a unique ip Adress using uuid4
+ringport = 12343
+
+##############################################################################################
+###############Threadig einfügen##############################################################
+#Loo until Leader= Falsch # Der neue Leader übernimmt diese Aufgabe
+
+########################In Bearbeitung#################- Nur hier wird die Globale Neughbour Angesprochen und Geupdated - Achtung Falsch muss um den Eing geleitet werden
+def sende_update_ring():
+ print("Ich Update den Ring")
+ Nachricht = json.dumps(members).encode() # Nachricht beinhaltet die Liste mit den Members
+ # Erstellen eines UDP-Sockets
+ sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+ # Setze den Socket in den Broadcast-Modus
+ sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+ # Sende die Nachricht an die Broadcast-Adresse
+ sock.sendto(Nachricht, (broadcast_ip, ringport))
+
+#Muss dauerhaft erfolgen
+def lausche_update_Ring():
+ global members
+ # Erstellen eines UDP-Sockets
+ sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+ # Setze den Socket in den Broadcast-Modus
+ sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+ # Sende die Nachricht an die Broadcast-Adresse
+ sock.bind(("0.0.0.0", ringport))
+ while True:
+ data, addr = sock.recvfrom(1024) # Antwort empfangen
+ try:
+ members = json.loads(data.decode())
+ print(f"Ring Update erhalten: {members}")
+ #nachricht_update_ring()
+ except json.JSONDecodeError:
+ print("Fehler beim Decodieren der JSON-Daten.")
+
+
+###########################################################################
+###########################################################################
+
+#Function of Leader. Server is listeng to the Port to greet new servers and Update Ring Topology
+def new_server_in_ring():
+ global members
+ # Erstellen eines UDP-Sockets
+ sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+ # Setze den Socket in den Broadcast-Modus
+ sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+ # Binde den Socket an die Adresse und den Port
+ sock.bind(("0.0.0.0", port))
+ print("Server läuft und wartet auf Broadcast-Nachrichten von neuen Servern.")
+ while True:
+ #Lauscht ob es ene Nachricht von anderen servern erhält
+ data, addr = sock.recvfrom(1024) # Puffergröße 1024 Bytes
+ print(f"Nachricht empfangen von {addr}: {data.decode()}")
+ #response = b"Antwort vom Server: Nachricht erhalten!"
+ # Sende die Antwort zurück an den neuen Server
+ #sock.sendto(response, addr)
+ #print(f"Antwort gesendet an {addr}")
+ new_server_ip, new_server_port = addr
+ new_ID = data.decode()
+ new_ID = new_ID.split(": ")[1]
+ #Prüfen ob die ID bereis vorhanden ist und Server nur kurz die Verbindung verloren hat. Kann eigemtlich nich eintreten, da ID immer neu generiert wird
+ if new_ID in members:
+ #msg = f"Welcome Back. Aktueller Ring: {json.dumps(members)}".encode()
+ Nachricht = json.dumps(members).encode()
+ else:
+ members.append(new_ID)
+ Nachricht = json.dumps(members).encode()
+ #msg = f"Updated Ring: {json.dumps(members)}".encode()
+ #Alle anderen im Ring auch noch benachrichtigen.... mit einer Funktion Update Ring()
+ #Neuneu neu
+ #sock.sendto(msg, addr)
+
+ ###einfügern
+ #message = json.dumps(members)
+ ###Testen ob es beim zweiten mal auch Funktioniert
+ print(f"Members des Rings sind: {members}")
+ sock.sendto(Nachricht, addr)
+ #Naxchricht noch an den anderen server senden!
+
+ #######################################################
+ #######################################################
+ #sende_update_ring()
+
+
+ #Wie kann ich MSG versenden ohne das die zerteilung der nachricht Falsch ist?
+
+#Server tritt bei und macht sich für andere Server bemerkbar
+def server_enters():
+ global members
+ msg = f"Ich bin neu: {my_ip}".encode() #Greeting message of the server entering the chat
+ # Erstellen eines UDP-Sockets
+ sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+ # Setze den Socket in den Broadcast-Modus
+ sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+ # Sende die Nachricht an die Broadcast-Adresse
+ sock.sendto(msg, (broadcast_ip, port))
+ # Warte etwas auf eine Antwort
+ sock.settimeout(2)
+ try:
+ data, addr = sock.recvfrom(1024) # Antwort empfangen
+ print(f"Antwort von {addr}")
+ #Liste der Members wird dem Neuzugang gesendet, Es wird geprüft, ob die json Datei ausgelesen werden kann. Json wird genutzt um Liste Vollständig zu übergeben
+ try:
+ members = json.loads(data.decode())
+ print(f"Der neue Ring ist: {members}")
+ #nachricht_update_ring()
+ except json.JSONDecodeError:
+ print("Fehler beim Decodieren der JSON-Daten.")
+
+
+
+ #Übergabe der Ring Teilnehmer durch den Server an Alle anderen Teilnehnmer!!
+ except socket.timeout:
+ #If no answer is received the server sets itself as leader
+ print(f"Keine Antwort erhalten. Ich bin jetzt der Leader. Meine ID: {my_ip}")
+ #Leader fügt sich selbst als Teilnehmer in den Ring ein
+
+ members.append(my_ip)
+ #Leader ruft die Funktion auf, um andere beiretenden Servern zu lauschen
+ #New New
+ #Global Leader
+ #Leader = True
+ new_server_in_ring()
+
+#Server tritt in den Ring ein/formt den Ring
+
+
+if __name__ == "__main__":
+ # Thread 1 und 2 erstellen
+ thread1 = f"Thread1-{my_ip}"
+ #thread2 = f"Thread2-{my_ip}"
+ #print(thread1)
+ #print(thread2)
+
+ thread1 = threading.Thread(target=server_enters)
+ thread2 = threading.Thread(target=lausche_update_Ring)
+
+ # Starten der Threads
+ thread1.start()
+ #thread2.start()
+
+
+# Schließe den Socket an welchem Punkt??
+#sock.close()