Skip to content
Snippets Groups Projects
Commit 14f467a2 authored by Katharina's avatar Katharina
Browse files

test server-client connection

parent e2a7a0ae
No related branches found
No related tags found
No related merge requests found
Show whitespace changes
Inline Side-by-side
2024-12-22_Server_V4.py
+ 2
− 1
View file @ 14f467a2
......@@ -192,6 +192,7 @@ def new_server_in_ring():
else:
members_IP.append(new_IP) # If the server is new, add its IP to the list
msg = f"There are already servers. I am the leader: {ip_address}" # Create a message for the new server
#AttributeError: 'bytes' object has no attribute 'encode'. Did you mean: 'decode'?
sock.sendto(msg.encode(), (new_IP, new_server_port)) # Send the greeting message back to the new server
print(f"The updated IP_Ring is: {members_IP}")
send_update_to_ring() # Update the ring topology
......@@ -406,7 +407,7 @@ def heartbeat():
message = json.dumps(list(last_three_messages))
print(f"Leader sendet Heartbeat: {message}")
server_socket.sendto(message.encode(), (broadcast_ip, heartbeat_port))
time.sleep(1)
time.sleep(5)
else:
# Empfang von Heartbeats
try:
......
2025-01-01_Client_V4.py 0 → 100644
+ 78
− 0
View file @ 14f467a2
import socket
import threading
import time
import uuid
broadcast_ip = '255.255.255.255'#change ip??? #hard coded?
broadcast_port = 55555
broadcast_port2 = 33333
#local host information
MY_HOST = socket.gethostname()
#socket.gethostbyname(socket.gethostname()) #getip
MY_IP = socket.gethostbyname(MY_HOST)
#print(f"host:{MY_HOST} and ip: {MY_IP}")
# create client-socket for broadcast
client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
client_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
client_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
#client_socket.bind(('', broadcast_port)) # listen on broadcast #socket is bind to ALL available IP addresses
listener_ready = threading.Event()
#listen for server?
def listen_server():
client_socket2 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
client_socket2.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
client_socket2.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
client_socket2.bind(('', broadcast_port2)) # listen on broadcast #socket is bind to ALL available IP addresses
"""receives messages from server."""
#listener_ready.set() #makes sure that listener is ready
while True:
try:
data, address = client_socket2.recvfrom(4096)
decoded_message = data.decode()
#print(f"Received {data.decode()} from {address}") #debug
#ignores broadcast messages with own ip #################please enable it after testing!!!!!!!!!!!!!!!!!!!S
#does not work
if address[0]==MY_IP:
continue
#print("this decoded msg", decoded_message) #debug
except socket.error as e:
print(f"An error occurred: {e}")
break
def sender():
"""Ermöglicht dem Benutzer, Nachrichten zu schreiben und zu senden."""
nickname = input("Enter your nickname: ")
just_nickname= f"{nickname} entered the chat".encode()
#client_socket.sendto(just_nickname, (broadcast_ip, broadcast_port))
client_socket.sendto(just_nickname, (broadcast_ip, broadcast_port))
#print("is it leader adresse here", leader_address)
while True:
message_id = str(uuid.uuid4())
#allows the client to send any message
message = input("")
#print("send message to", broadcast_port)
#checks for whitemarks
if message.strip():
full_message = f"{message_id}: {nickname}: {message}".encode()
client_socket.sendto(full_message, (broadcast_ip, broadcast_port))
#print("message sended to", broadcast_port)
###############main#################################
if __name__ == "__main__":
# Start listener thread
listen_thread = threading.Thread(target=listen_server)
listen_thread.daemon = True
listen_thread.start()
#listener_ready.wait()
sender_thread = threading.Thread(target=sender)
sender_thread.start()
\ No newline at end of file
Server_A.py deleted 100644 → 0
+ 0
− 47
View file @ e2a7a0ae
import socket
import os
import dynamic
import leaderServer
import uuid
#Server Informationen
server_adress = '127.0.0.1'
server_port = 10001
# Server aufsetzen
server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server_socket.bind((server_adress, server_port))
print('Server A up and run at {} : {}'.format(server_adress,server_port))
# Eindeutige ID des Servers
server_id = str(uuid.uuid4())
# Name des Rechners
#hostName = socket.gethostname()
#print(hostName)
# IP des Rechners im Subnetz
#hostIP = socket.gethostbyname(hostName)
#print(hostIP)
dynamic.broadcast_sender(leaderServer.broadcast_ip, leaderServer.broadcast_port, server_adress, server_id)
print(f"send broadcast of server a id: {server_id}")#debug
while True:
print(f"server a before broadcast sender: {leaderServer.leader}")
print(f"server a before broadcast sender: {leaderServer.server_network}")
data = dynamic.broadcast_listener(leaderServer.broadcast_ip, leaderServer.broadcast_port)
#data = leaderServer.leader
print(f"after broadcast sender: {leaderServer.server_network}")
if data:
#x = data
print(data)
# if d in leaderServer.leader:
# leaderServer.server_network = leaderServer.addServer(data)
# dynamic.broadcast_sender(leaderServer.broadcast_ip, leaderServer.broadcast_port, leaderServer.server_network)
# print(leaderServer.server_network)
# else:
# print("ich bin kein leader")
else:
print("no data")
\ No newline at end of file
Server_B.py deleted 100644 → 0
+ 0
− 31
View file @ e2a7a0ae
import socket
import os
import dynamic
import leaderServer
import uuid
#Server Informationen
server_adress = '127.0.0.2'
server_port = 10002
# Server aufsetzen
server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server_socket.bind((server_adress, server_port))
print('Server B up and run at {} : {}'.format(server_adress,server_port))
server_id = str(uuid.uuid4())
# Name des Rechners
hostName = socket.gethostname()
# IP des Rechners im Subnetz
hostIP = socket.gethostbyname(hostName)
print(f"server b before broadcast sender: {leaderServer.leader}")
print(f"server b before broadcast sender: {leaderServer.server_network}")
dynamic.broadcast_sender(leaderServer.broadcast_ip, leaderServer.broadcast_port, server_adress, server_id)
print(f"send broadcast of server b id: {server_id}")#debug
while True:
server_network = dynamic.broadcast_listener(leaderServer.broadcast_ip, leaderServer.broadcast_port)
print(f"server in network: {leaderServer.server_network}")
print(f"leader in network: {leaderServer.leader}")
dynamic.py deleted 100644 → 0
+ 0
− 61
View file @ e2a7a0ae
# Problem 1: Client will einem Chat beitreten und weiß nicht welchen Server er kontaktieren muss
# Problem 2: ein server will einem netzwerk beitreten
# for dynamic discovery Broadcast (UDP Only) to all members of a network is necessary
# 1. neuer server_A sendet Broadcast Nachricht an Broadcastadress (letzte IP-Adresse in einem Netzwerk oder berechnen über OnlineTool Vorlesungfolien) mit seiner eigenen ip-adresse
# -> Leader_Server müssen konstant listen auf die Broadcastadress
# -> Server_B updatet seine 'group View' (wenn man einen Leader hat nicht notwendig)
# -> Leader_Server sendet ip Adressen aller Server zurück
# 2. Server sammelt alle IP-adressen und speichert diese ab
# -> Jeder Server hat eine list 'group Vview mit den adressen aller Server' (wenn man einen Leader hat nicht notwendig)
from base64 import encode
import socket
import leaderServer
buffer_size = 4096
def broadcast_sender(broadcast_ip, broadcast_port, server_ip, server_uuid):
#create UDP socket
broadcast_socket = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
#print(leaderServer.leader)
message = f"{server_ip}::{server_uuid}"
if len(leaderServer.leader) == 0:
leaderServer.addLeader(server_uuid)
leaderServer.addServer(server_ip)
print(f"Hi {leaderServer.leader}")
print(f'Hi {leaderServer.server_network}')
broadcast_socket.sendto(str(message).encode(), (broadcast_ip, broadcast_port))#for debug
else:
#send message
broadcast_socket.sendto(str(message).encode(), (broadcast_ip, broadcast_port))
print(f'else {leaderServer.server_network}')#for debug
def broadcast_listener(ip_adress, port):
print(f"listener{leaderServer.leader}")#f for debug
print(leaderServer.server_network)
#UDP socket
listen_socket = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
#set socket to broadcast and enable reusing adress
listen_socket.setsockopt(socket.SOL_SOCKET,socket.SO_BROADCAST, 1)
listen_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR, 1)
#bind socket adress and Port
listen_socket.bind((ip_adress, port))
print('listener up and run at {} : {}'.format(ip_adress, port))
data, address = listen_socket.recvfrom(buffer_size)
#hier jetzt async einbauen für ständige listen?
message=data.decode()
server_ip, server_uuid = message.split("::")
#if len(leaderServer.leader) == 0:
leaderServer.addLeader(server_uuid)
leaderServer.addServer(server_ip)
print(f"Hi {leaderServer.leader}")
print(f'Hi {leaderServer.server_network}')
print("Broadcast recieved from Sender: ", data.decode())
print(f"this is address: {address}")
return data.decode()
leaderServer.py deleted 100644 → 0
+ 0
− 39
View file @ e2a7a0ae
# Hier werden informationen gespeichert die für alle zugänglich sein müssen. Für den auf Funktionen und Attribute muss der 'import LeaderServer' gemacht werden
#
#
#
# Broadcast Informationen
broadcast_ip = '127.0.0.255' #192.168.1.255
broadcast_port = 5000
# Alle IP adressen der beteiligten Server
server_network = []
# Alle IP adressen der User
user = []
# UUID des Leaders
leader = []
# Server einer Liste hinzufügen
def addServer(Server_ip):
server_network.append(Server_ip)
return server_network
# Leader hinzufügen
def addLeader(server_uuid):
leader.append(server_uuid)
#return leader
# löschen eines Servers
def deleteServer(server_ip):
global server_network
if server_ip in server_network:
server_network.remove(server_ip)
else:
print("Server Nicht in Liste")
ring_update.py deleted 100644 → 0
+ 0
− 151
View file @ e2a7a0ae
#Ring testebn
#Forming a Ring
import time
import threading
from uuid import uuid4
import socket
import uuid
import json
import neighbour
#Neu
leader = False
#dict member = {"uuid": {"IP",}}
#Definition Atribute
global members_UUID
global member_IP
members_UUID = [] #List for members in the ring
member_IP = [] #List for ip Adresses of the members
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_ID = str(uuid.uuid4()) #Creating a unique ip Adress using uuid4
ringport = 12343
hostname = socket.gethostname()
ip_address = socket.gethostbyname(hostname)
#Muss dauerhaft erfolgen
def lausche_update_Ring():
global member_IP
# 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:
try:
data, addr = sock.recvfrom(1024) # Antwort empfangen
member_IP = json.loads(data.decode())
print(f"Ring Update erhalten: {member_IP}")
#send_update_to_ring()
#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_UUID
global member_IP
# 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()}")
msg = 'es gibt bereits server'
new_server_ip, new_server_port = addr
new_ID = data.decode()
new_ID = new_ID.split(": ")[1]
# ??? notwendig ???
#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_UUID:
#msg = f"Welcome Back. Aktueller Ring: {json.dumps(members)}".encode()
Nachricht = json.dumps(members_UUID).encode()
else:
members_UUID.append(new_ID)
member_IP.append(new_server_ip)
sock.sendto(msg.encode(), (new_server_ip, new_server_port))
print(f"Members des Rings sind: {members_UUID}")
print(f"Der neue IP_Ring ist: {member_IP}")
#Ring Update losschicken
send_update_to_ring()
#Server tritt bei und macht sich für andere Server bemerkbar
def server_enters():
global members_UUID
msg = f"Ich bin neu: {my_ID}".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}: {data.decode()}")
lausche_update_Ring()
sock.close()
#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_UUID = json.loads(data.decode())
#print(f"Der neue Ring ist: {members_UUID}")
#print(f"Der neue IP_Ring ist: {member_IP}")
#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_ID}")
#Leader fügt sich selbst als Teilnehmer in den Ring ein
members_UUID.append(my_ID)
member_IP.append(ip_address)
sock.close()
new_server_in_ring()
#Server tritt in den Ring ein/formt den Ring
def send_update_to_ring():
global member_IP
right_neighbour = neighbour.get_neighbour(member_IP, ip_address, 'right')
if not right_neighbour:
print("No left neighbour to send updates.")
return
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
data = json.dumps(member_IP).encode()
try:
sock.sendto(data, (right_neighbour , ringport))
except Exception as e:
print(f"Error sending data: {e}")
sock.close()
'LUCA' #Multiprosessing einfügen
if __name__ == "__main__":
# Thread 1 und 2 erstellen
thread1 = f"Thread1-{my_ID}"
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()
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please to comment