Add files via upload

Author: Cizr

DISTRIBUTED ALGORITHMS/Basic multi client- one server communication (tcpip)/client1.py

@@ -0,0 +1,27 @@
+import socket
+import threading
+
+message_lock = threading.Lock()
+
+def start_client():
+    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    client_socket.connect(('localhost', 8888))
+
+    while True:
+        message = input("Enter a message (type 'exit' to end): ")
+
+        with message_lock:
+            client_socket.send(message.encode('utf-8'))
+            if message.lower() == 'exit':
+                break
+
+            # Notify the client that the server is processing
+            print("Waiting for server response...")
+
+            response = client_socket.recv(1024).decode('utf-8')
+            print("Server response:", response)
+
+    client_socket.close()
+
+if __name__ == "__main__":
+    start_client()

DISTRIBUTED ALGORITHMS/Basic multi client- one server communication (tcpip)/client2.py

@@ -0,0 +1,27 @@
+import socket
+import threading
+
+message_lock = threading.Lock()
+
+def start_client():
+    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    client_socket.connect(('localhost', 8888))
+
+    while True:
+        message = input("Enter a message (type 'exit' to end): ")
+
+        with message_lock:
+            client_socket.send(message.encode('utf-8'))
+            if message.lower() == 'exit':
+                break
+
+            # Notify the client that the server is processing
+            print("Waiting for server response...")
+
+            response = client_socket.recv(1024).decode('utf-8')
+            print("Server response:", response)
+
+    client_socket.close()
+
+if __name__ == "__main__":
+    start_client()

DISTRIBUTED ALGORITHMS/Basic multi client- one server communication (tcpip)/explaining.txt

@@ -0,0 +1,43 @@
+{print_lock} # ensures that only one thread at a time can access and print to the console. 
+This helps avoid conflicts and improves the clarity of the printed messages.
+
+
+
+{client_connections = {}} #  stores the active connections with client IDs as keys and their corresponding socket connections as values
+Purp: The server needs to manage multiple client connections simultaneously when we use dictionary
+it can easily look up and interact with individual clients based on their unique identifiers (client IDs).
+Usage: When a new client connects its connection is added to this dictionary. 
+This allows the server to send responses back to specific clients by referencing their client IDs.
+
+
+
+{The client_counter} variable is used to assign unique client IDs to each connected client. 
+Structure: client_counter is a numeric variable that starts at 1. 
+It gets incremented by 1 for each new client, thereby providing a unique value for each client.
+Usage: When a new client connects the server generates a client ID by combining the string "Client " with the current value of client_counter.
+ This results in client IDs like "Client 1", "Client 2", and so on.
+
+
+
+threading.Thread(...): This creates a new thread using the Thread class from the threading module.
+target=process_messages: Specifies that the function process_messages will be the target function that the new thread runs.
+daemon=True:Daemon threads are background threads that are automatically terminated when the main program (in this case, the server) exits.
+.start(): initiates the execution of the thread causing it to begin running the process_messages function concurrently with the rest of the server.
+
+
+
+
+
+Summary:
+
+The script creates a server that handles multiple client connections concurrently.
+A mutex (print_lock) ensures synchronized printing to avoid overlapping console output.
+A message queue (message_queue) is used to store messages from clients.
+Client connections are tracked in a dictionary (client_connections) using unique client IDs.
+Separate threads are employed to handle communication with each connected client and to process messages concurrently.
+The server listens for incoming connections, assigns unique client IDs, and starts threads for communication handling.
+A daemon thread is used to process messages concurrently with the main server program.
+The script gracefully handles a keyboard interrupt, printing a shutdown message, and closes the server socket upon termination.
+
+
+

DISTRIBUTED ALGORITHMS/Basic multi client- one server communication (tcpip)/serverv3.py

@@ -0,0 +1,113 @@
+import socket
+import threading
+import queue
+import time
+
+#to create a mutex (mutual exclusion) and ensure synchronized printing to avoid overlapping console output
+print_lock = threading.Lock()
+
+#queue so we can store messages from clients
+message_queue = queue.Queue()
+
+#stores the active connections with client IDs
+client_connections = {}
+
+#just func to handle communication with each connected client
+def handle_client(connection, address, client_id):
+    #Output connection message when a client connects
+    with print_lock:
+        print(f"Connected to {client_id} at address: {address}")
+
+    while True:
+        #receiving data from the client
+        data = connection.recv(1024).decode('utf-8')
+
+        #But we check if data is empty maybe client disconnected
+        if not data:
+            break
+
+        #output received message from the client
+        with print_lock:
+            print(f"Received from {client_id}: {data}")
+
+        #the received message will be along with client_id into the message queue
+        message_queue.put((client_id, data))
+
+    #if client disconnects close
+    connection.close()
+
+    #remove client IDs connection from the dictionary
+    with print_lock:
+        print(f"Connection with {client_id} closed.")
+        del client_connections[client_id]
+
+#func to process messages 
+def process_messages():
+    while True:
+        #first we check if the message queue is not empty
+        if not message_queue.empty():
+            with print_lock:
+                #getting the client_id and message from the message queue
+                client_id, message = message_queue.get()
+
+                #entering a response for the client
+                response = input(f"Enter your response for {client_id}: ")
+
+                #another output response
+                print(f"Response to {client_id}: {response}")
+
+                #checking if the client is still connected
+                if client_id in client_connections:
+                    #we send the response back to the client
+                    client_connections[client_id].send(response.encode('utf-8'))
+
+                #1sec delay to handle safety
+                time.sleep(1)
+
+#func to start the server
+def start_server():
+    #socket for server
+    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+
+    #Binding the socket to a specific address and port
+    server_socket.bind(('localhost', 8888))
+
+    #listening for incoming connections (5 clients in the queue)
+    server_socket.listen(5)
+
+    #showing that the server is running
+    with print_lock:
+        print("Server is running and waiting for connections...")
+
+    #used to assign unique client IDs to each connected client
+    client_counter = 1
+
+    try:
+        #"process_messages" function runs in a separate thread process messages from clients
+        #The use of a daemon thread ensures that the thread terminates when the server program exits
+        threading.Thread(target=process_messages, daemon=True).start()
+
+        while True:
+            #accepting new connection from a client
+            connection, address = server_socket.accept()
+
+            #generating a unique client ID
+            client_id = f"Client {client_counter}"
+            client_counter += 1
+
+            #storing the client connection in the dictionary
+            client_connections[client_id] = connection
+
+            #to handle communication with the client start a new thread
+            client_thread = threading.Thread(target=handle_client, args=(connection, address, client_id))
+            client_thread.start()
+
+    except KeyboardInterrupt:
+        #keyboard interrupt
+        with print_lock:
+            print("Server shutting down.")
+    finally:
+        server_socket.close()
+
+if __name__ == "__main__":
+    start_server()

DISTRIBUTED ALGORITHMS/ClientServer Numbers/client.py

@@ -0,0 +1,31 @@
+import socket
+
+def send_number_to_server(number):
+    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    client_socket.connect(('127.0.0.1', 12345))
+    
+    while True:
+        client_socket.send(str(number).encode('utf-8'))
+
+        data = client_socket.recv(1024)
+        result = data.decode('utf-8')
+        print(f"Server response: {result}")
+
+        user_input = input("Enter a number or type 'exit' to quit: ")
+        if user_input.lower() == 'exit':
+            break
+
+        try:
+            number = int(user_input)
+        except ValueError:
+            print("Invalid input. Please enter a valid number.")
+
+    client_socket.close()
+
+if __name__ == "__main__":
+    user_input = input("Enter a number: ")
+    try:
+        number = int(user_input)
+        send_number_to_server(number)
+    except ValueError:
+        print("Invalid input. Please enter a valid number.")

DISTRIBUTED ALGORITHMS/ClientServer Numbers/server.py

@@ -0,0 +1,70 @@
+import socket
+import threading
+
+def handle_client(client_socket, client_address):
+    try:
+        while True:
+            # Receive data from the client in chunks of 1024 bytes
+            data = client_socket.recv(1024)
+            # If no more data is received, break out of the loop
+            if not data:
+                break
+
+            # Decode the received data to a UTF-8 string and print it on the server side
+            command = data.decode('utf-8')
+            print(f"Received from {client_address}: {command}")
+
+            # If the client sends 'exit', break out of the loop and close the connection
+            if command.lower() == "exit":
+                break
+
+            try:
+                # If the received command is a valid integer, double it and send back to the client
+                number = int(command)
+                result = number * 2
+                client_socket.send(str(result).encode('utf-8'))
+            except ValueError:
+                # If the conversion to integer fails, send an error message to the client
+                client_socket.send("Invalid input. Please enter a valid number or type 'exit' to quit.".encode('utf-8'))
+
+    except Exception as e:
+        # Catch any unexpected exceptions during communication and print for debugging
+        print(f"Error handling client {client_address}: {str(e)}")
+    finally:
+        # Print a message about closing the connection and close the client socket
+        print(f"Closing connection from {client_address}")
+        client_socket.close()
+
+def start_server():
+    # Create a socket for the server with IPv4 address family and TCP socket type
+    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    # Bind the server socket to the address ('127.0.0.1', 12345)
+    server_socket.bind(('127.0.0.1', 12345))
+    # Allow up to 5 queued connections
+    server_socket.listen(5)
+    # Print a message indicating that the server is listening
+    print("Server listening on port 12345")
+
+    try:
+        while True:
+            # Accept an incoming connection and get the client socket and address
+            client_socket, client_address = server_socket.accept()
+            # Print a message about the accepted connection
+            print(f"Accepted connection from {client_address}")
+
+            # Create a new thread for handling communication with the connected client
+            client_thread = threading.Thread(target=handle_client, args=(client_socket, client_address))
+            # Start the thread to handle the client
+            client_thread.start()
+
+    except KeyboardInterrupt:
+        # Handle a keyboard interrupt (Ctrl+C) to gracefully shut down the server
+        print("Server shutting down.")
+    finally:
+        # Close the server socket in the finally block to ensure cleanup
+        server_socket.close()
+
+# Main entry point
+if __name__ == "__main__":
+    # Call the start_server function to initiate the server
+    start_server()