server.py

import socket
import threading
import platform
from email.utils import formatdate
from peer import Peer
from rfc import RFC
from utilities import parse_request

class Server:
    def __init__(self, server_ip, server_port=7734):
        self.socket_info = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.server_ip = server_ip
        self.server_port = server_port
        self.version = "P2P-CI/1.0"
        self.client_connections = [] # A list of current active client connections
        self.peers_list = {} # A mapping between hostname and the Peer object
        self.rfc_files = {}
        self._shutdown_event = threading.Event()
        self.client_threads = []
        self.conn_peer_map = {}  # Track which peer is tied to which socket for cleanup
    
    def print_rfc_files(self):
        print('-------------------------------------------------')
        print('RFCs LIST:')
        print('-------------------------------------------------')
        for rfc_number, details in self.rfc_files.items():
            rfc = details['rfc_details']
            peers = details['peer']
            peer_info = ', '.join([f"{peer.hostname}:{peer.peer_port}" for peer in peers])
            print(f"RFC {rfc.rfc_number}: {rfc.rfc_title} \n Peers: {peer_info}")
    
    def print_peers(self):
        print('-------------------------------------------------')
        print('PEERS LIST:')
        print('-------------------------------------------------')

        for peer_key, peer in self.peers_list.items():
            rfc_info = ', '.join([str(rfc) for rfc in peer.rfc_files])
            print(f"\nPeer {peer_key} - {rfc_info} \n")
    
    def add_rfc(self, rfc, peer):
        if rfc.rfc_number in self.rfc_files.keys(): 
            peer_list = self.rfc_files[rfc.rfc_number]['peer']
            if peer not in peer_list:
                self.rfc_files[rfc.rfc_number]['peer'].append(peer)
        else: 
            self.rfc_files[rfc.rfc_number] = {'rfc_details': rfc, 'peer': [peer]}

    def get_list_peers(self):
        return self.peers
    
    def get_list_rfc_files_for_peer(self, hostname, peer_port):
        return self.peers_list[f"{hostname}:{peer_port}"].rfc_files if f"{hostname}:{peer_port}" in self.peers_list else []
    
    def get_list_peers_for_rfc(self, rfc_number):
        return [entry['peer'] for entry in self.rfc_files[rfc_number]] if rfc_number in self.rfc_files else []
    
    def add_peer(self, hostname, peer_port, rfc):
        peer_key = f"{hostname}:{peer_port}"
        if peer_key in self.peers_list:
            peer = self.peers_list[peer_key]
            peer.check_rfc_exists(rfc.rfc_number) or peer.add_rfc_files([rfc])
        else:
            peer = Peer(hostname, peer_port, [rfc])
            self.peers_list[peer_key] = peer
        return peer

    def remove_peer(self, hostname, peer_port):
        """Remove peer and associated RFC entries, then print state."""
        peer_key = f"{hostname}:{peer_port}"
        if peer_key in self.peers_list:
            peer_obj = self.peers_list.pop(peer_key)
            to_delete = []
            for rfc_number, details in list(self.rfc_files.items()):
                if peer_obj in details['peer']:
                    details['peer'].remove(peer_obj)
                if not details['peer']:
                    to_delete.append(rfc_number)
            for rnum in to_delete:
                self.rfc_files.pop(rnum, None)
        self.print_rfc_files()
        self.print_peers()
    
    def create_rfc_file(self, rfc_number, rfc_title):
        print(f"Creating RFC file with number: {rfc_number}, title: {rfc_title}")
        return RFC(rfc_number, rfc_title)
    
    def handle_client_connection(self, client_socket):
        peer_identity = None
        # Make recv interruptible so we can shut down gracefully
        try:
            client_socket.settimeout(1.0)
        except Exception:
            pass
        while not self._shutdown_event.is_set():
            try:
                data = client_socket.recv(1024)
            except socket.timeout:
                continue
            except OSError:
                break
            if not data:
                break
            request = data.decode('utf-8')
            print(f"\nReceived request: \n{request}")
            method, version, parameters, headers, body = parse_request(request=request)
            # Version check
            if version != self.version:
                response = self.server_response_template(505, "P2P-CI Version Not Supported")
                client_socket.sendall(response.encode('utf-8'))
                continue
            if method == 'ADD':
                rfc = self.create_rfc_file(parameters[1], headers['Title'])
                self.add_peer(headers['Host'], headers['Port'], rfc)
                self.add_rfc(rfc, self.peers_list[f"{headers['Host']}:{headers['Port']}"])
                peer_identity = (headers['Host'], headers['Port'])
                self.conn_peer_map[client_socket] = peer_identity
                response = self.server_response_template(200, "OK", [f"RFC {rfc.rfc_number} {rfc.rfc_title} {headers['Host']} {headers['Port']}"])
                print(response)
                client_socket.sendall(response.encode('utf-8'))
                self.print_rfc_files()
                self.print_peers()
            elif method == 'LOOKUP':
                if not parameters[1] in self.rfc_files.keys():
                    response = self.server_response_template(404, "Not Found", [])
                    client_socket.sendall(response.encode('utf-8'))
                    continue
                peer_list = self.rfc_files[parameters[1]]['peer']
                rfc = self.rfc_files[parameters[1]]['rfc_details']
                response = self.server_response_template(200, "OK", [f"RFC {rfc.rfc_number} {rfc.rfc_title} {peer.hostname} {peer.peer_port}" for peer in peer_list])
                client_socket.sendall(response.encode('utf-8'))
            elif method == 'LIST':
                if not self.rfc_files.keys():
                    response = self.server_response_template(404, "Not Found", [])
                    client_socket.sendall(response.encode('utf-8'))
                    continue
                response_body = []
                for inner_dict in self.rfc_files.values():
                    rfc_details = inner_dict['rfc_details']
                    peer = inner_dict['peer']
                    response_body.extend([f"RFC {rfc_details.rfc_number} {rfc_details.rfc_title} {p.hostname} {p.peer_port}" for p in peer])
                response = self.server_response_template(200, "OK", response_body)
                client_socket.sendall(response.encode('utf-8'))
            elif method == 'LEAVE':
                host = headers.get('Host')
                port = headers.get('Port')
                if host and port:
                    self.remove_peer(host, port)
                response = self.server_response_template(200, "OK", [])
                client_socket.sendall(response.encode('utf-8'))
                break
            else:
                response = self.server_response_template(400, "Bad Request", [])
                client_socket.sendall(response.encode('utf-8'))
        # Cleanup on disconnect
        if peer_identity:
            host, port = peer_identity
            self.remove_peer(host, port)
    
    def spin_up(self):
        print(f"Server running on {self.server_ip}:{self.server_port}")
        try:
            self.socket_info.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        except Exception:
            pass
        self.socket_info.bind((self.server_ip, self.server_port))
        self.socket_info.listen()
        try:
            self.socket_info.settimeout(1.0)
        except Exception:
            pass
        print("Server is listening for incoming connections.")

        while not self._shutdown_event.is_set():
            try:
                client_socket, addr = self.socket_info.accept()
            except socket.timeout:
                continue
            except OSError:
                break
            print(f"\nConnection established with client at {addr}")
            self.client_connections.append(client_socket)
            threaded_client = threading.Thread(target=self.handle_client_connection, args=(client_socket,), daemon=True)
            self.client_threads.append(threaded_client)
            threaded_client.start()

    def shutdown(self):
        if self._shutdown_event.is_set():
            return
        print("Shutting down server...")
        self._shutdown_event.set()
        try:
            self.socket_info.close()
        except Exception:
            pass
        for conn in list(self.client_connections):
            try:
                try:
                    conn.shutdown(socket.SHUT_RDWR)
                except Exception:
                    pass
                conn.close()
            except Exception:
                pass
        for t in list(self.client_threads):
            if t.is_alive():
                t.join(timeout=1.0)
        print("Server successfully shut down.")
    
    def server_response_template(self, status_code, phrase, body=[]):
        # Basic headers for compliance; body lines follow after a blank line
        response = f"{self.version} {status_code} {phrase}\r\n"
        response += f"Date: {formatdate(usegmt=True)}\r\n"
        response += f"OS: {platform.system()} {platform.release()}\r\n"
        response += f"Server: P2P-CI-Server\r\n"
        response += f"\r\n"
        for line in body:
            response += f"{line}\r\n"
        return response

if __name__ == "__main__":
    server = Server("127.0.0.1")

    try:
        server.spin_up()
    except KeyboardInterrupt:
        print('\nKeyboardInterrupt received. Shutting down server...')
    except Exception as e:
        print(f"\nAn unhandled error occurred: {e}\n\n Shutting down server...")
    finally:
        server.shutdown()
        server.print_rfc_files()
        server.print_peers()