Improved documentation, and fixed issue of needing another file to read messages.

Author: TiagoValdrich

README.md

@@ -0,0 +1,65 @@
+# Simple Socket Chat
+
+Simple chat project, written in Python using sockets for college network class.
+
+## Requirements
+
+In order to run the project, you'll need to have Python 3.7.6 or greater, in case that you already have it you can go to next section: **Running the project**.
+If you don't have it you can use [pyenv](https://github.com/pyenv/pyenv) with [pyenv-virtualenv](https://github.com/pyenv/pyenv-virtualenv) 
+for download python and create your python environment for running the project.
+
+I'm going to leave below a tutorial of how to configure your environment for running the project using `pyenv` with `pyenv-virtualenv`.
+
+### Installing Python with `pyenv`
+
+```bash
+$ pyenv install 3.7.6
+```
+
+### Creating virtual environment
+
+```bash
+$ pyenv virtualenv 3.7.6 socketchat
+```
+
+### Using the virtual environment
+
+```bash
+$ pyenv activate socketchat
+```
+
+## Running the project
+
+For running the project, you will need to have an server to receive and send messages to
+clients that are connected, and at least 2 clients to see messages being broadcasted.
+
+- Creating the server:
+
+    If you are using Python 3.7.6 without `pyenv`, run the following command below to start 
+    running server:
+    ```bash
+    $ python3 server.py
+    ```
+
+    If you are using `pyenv`, just run the following command to up the server:
+    ```bash
+    (socketchat) $ python server.py
+    ```
+
+- Creating clients:
+
+    Now we are going to need two clients, in order to see each other message on terminal.
+
+    If you are using Python 3.7.6 without `pyenv`, run the following command in two different
+    terminals/bashes in order to create our clients and exchange messagens between them.
+    ```bash
+    $ python3 client.py
+    ```
+
+    Otherwise if you are using `pyenv`, simply run the following code in different terminals/bashes:
+    ```bash
+    (socketchat) $ python client.py
+    ```
+
+> If you are a client and want to quit from chat, simply write `quit` and you will be 
+> disconnected from the chat.

client.py

@@ -1,25 +1,62 @@
-import socket
+import socket, threading, time
+
+def handle_messages(connection: socket.socket):
+    '''
+        Receive messages sent by the server and display them to user
+    '''
+
+    while True:
+        try:
+            msg = connection.recv(1024)
+
+            # If there is no message, there is a chance that connection has closed
+            # so the connection will be closed and an error will be displayed.
+            # If not, it will try to decode message in order to show to user.
+            if msg:
+                print(msg.decode())
+            else:
+                connection.close()
+                break
+
+        except Exception as e:
+            print(f'Error handling message from server: {e}')
+            connection.close()
+            break
 
 def client() -> None:
+    '''
+        Main process that start client connection to the server 
+        and handle it's input messages
+    '''
+
     SERVER_ADDRESS = '127.0.0.1'
     SERVER_PORT = 12000
 
     try:
+        # Instantiate socket and start connection with server
         socket_instance = socket.socket()
         socket_instance.connect((SERVER_ADDRESS, SERVER_PORT))
+        # Create a thread in order to handle messages sent by server
+        threading.Thread(target=handle_messages, args=[socket_instance]).start()
 
+        print('Connected to chat!')
+
+        # Read user's input until it quit from chat and close connection
         while True:
-            msg = input('Insert a message: ')
+            msg = input()
 
             if msg == 'quit':
                 break
 
+            # Parse message to utf-8
             socket_instance.send(msg.encode())
 
+        # Close connection with the server
         socket_instance.close()
 
     except Exception as e:
         print(f'Error connecting to server socket {e}')
+        socket_instance.close()
 
 
 if __name__ == "__main__":

messages.py

@@ -1,61 +1,100 @@
-import socket, _thread
+import socket, threading
 
+# Global variable that mantain client's connections
 connections = []
 
 def handle_user_connection(connection: socket.socket, address: str) -> None:
+    '''
+        Get user connection in order to keep receiving their messages and
+        sent to others users/connections.
+    '''
     while True:
         try:
-            msg = connection.recv(1024).decode()
+            # Get client message
+            msg = connection.recv(1024)
 
+            # If no message is received, there is a chance that connection has ended
+            # so in this case, we need to close connection and remove it from connections list.
             if msg:
-                print(f'{address[0]}:{address[1]} - {msg}')
-
-                msg_to_send = f'From {address[0]}:{address[1]} - {msg}'
-
+                # Log message sent by user
+                print(f'{address[0]}:{address[1]} - {msg.decode()}')
+                
+                # Build message format and broadcast to users connected on server
+                msg_to_send = f'From {address[0]}:{address[1]} - {msg.decode()}'
                 broadcast(msg_to_send, connection)
+
+            # Close connection if no message was sent
             else:
                 remove_connection(connection)
                 break
+
         except Exception as e:
             print(f'Error to handle user connection: {e}')
             remove_connection(connection)
             break
 
 
 def broadcast(message: str, connection: socket.socket) -> None:
+    '''
+        Broadcast message to all users connected to the server
+    '''
+
+    # Iterate on connections in order to send message to all client's connected
     for client_conn in connections:
+        # Check if isn't the connection of who's send
         if client_conn != connection:
             try:
+                # Sending message to client connection
                 client_conn.send(message.encode())
-            except:
+
+            # if it fails, there is a chance of socket has died
+            except Exception as e:
+                print('Error broadcasting message: {e}')
                 remove_connection(client_conn)
 
+
 def remove_connection(conn: socket.socket) -> None:
+    '''
+        Remove specified connection from connections list
+    '''
+
+    # Check if connection exists on connections list
     if conn in connections:
+        # Close socket connection and remove connection from connections list
         conn.close()
         connections.remove(conn)
 
 
 def server() -> None:
+    '''
+        Main process that receive client's connections and start a new thread
+        to handle their messages
+    '''
+
     LISTENING_PORT = 12000
 
     try:
+        # Create server and specifying that it can only handle 4 connections by time!
         socket_instance = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-
         socket_instance.bind(('', LISTENING_PORT))
         socket_instance.listen(4)
+
+        print('Server running!')
 
         while True:
 
+            # Accept client connection
             socket_connection, address = socket_instance.accept()
-
+            # Add client connection to connections list
             connections.append(socket_connection)
-
-            _thread.start_new_thread(handle_user_connection, (socket_connection, address))
+            # Start a new thread to handle client connection and receive it's messages
+            # in order to send to others connections
+            threading.Thread(target=handle_user_connection, args=[socket_connection, address]).start()
 
     except Exception as e:
         print(f'An error has occurred when instancing socket: {e}')
     finally:
+        # In case of any problem we clean all connections and close the server connection
         if len(connections) > 0:
             for conn in connections:
                 remove_connection(conn)