Gossip algorithm in distributed systems

First off, you should be using docstrings to describe your functions and classes, not regular comments. A typical docstring might look something like this:

def my_func( ... ):
    """
    Describe my_func and it's arguments
    in detail here.
    """
    ...

Secondly, you have a few useless comments, like # sleep for 2 seconds in order to show difference in time, or # call the threads to begin the magic. Comments like these are fairly useless and can be removed.

Other than that, this code is really nice looking!

I've edited the code you wrote above to make it such that the nodes would continue to listen and broadcast messages even after the first message. I don't know if it was intentional, but it seems that your script is removing the connected nodes after just the first message, which I find weird... In any case, try the code below and let me know what you think! The only thing that I have not added yet, is that if the same message is sent twice, the nodes will ignore as they think that they have already received it. This can be fixed by adding timestamps to the messages, and I will work on that soon!

import random
import socket
from threading import Thread
import time
from datetime import datetime


class GossipNode:
    # pass the port of the node and the ports of the nodes connected to it
    def __init__(self, port, connected_nodes):
        # create a new socket instance
        # use SOCK_DGRAM to be able to send data without a connection
        # being established (connectionless protocol)
        self.node = socket.socket(type=socket.SOCK_DGRAM)
        self.previous_message = ''

        # set the address, i.e(hostname and port) of the socket
        self.hostname = socket.gethostname()
        self.port = port

        # bind the address to the socket created
        self.node.bind((self.hostname, self.port))

        # set the ports of the nodes connected to it as susceptible nodes
        self.susceptible_nodes = connected_nodes

        # call the threads to begin the magic
        self.start_threads()

    def input_message(self):
        while True:
            # input message to send to all nodes
            message_to_send = input("Enter a message to send: ")

            # call send message method and pass the input message.
            # encode the message into ascii
            self.transmit_message(message_to_send.encode('ascii'), 0)

    def receive_message(self):
        while True:

            # since we are using connectionless protocol,
            # we will use 'recvfrom' to receive UDP message
            
            message_to_forward, address = self.node.recvfrom(1024)
            

            if self.previous_message == message_to_forward:
                continue
            self.previous_message = message_to_forward


            previous_node = address[1]
            print('\nMessage to forward, address: {}, {}'.format(message_to_forward, address[1]))

            # sleep for 2 seconds in order to show difference in time
            time.sleep(1)

            # print message with the current time.
            # decode message so as to print it, as it was sent
            print("\nReceived message: '{0}'. From [{1}]"
                    .format(message_to_forward.decode('ascii'), address[1]))

            # call send message to forward the message to other susceptible(connected) nodes
            self.transmit_message(message_to_forward, previous_node)

    def transmit_message(self, message, previous_node=0):
        for i in range(len(self.susceptible_nodes)):
            selected_port = self.susceptible_nodes[i]

            if selected_port == previous_node:
                continue

            # since we are using connectionless protocol,
            # we will use 'sendto' to transmit the UDP message
            self.node.sendto(message, (self.hostname, selected_port))

            time.sleep(1)

    def start_threads(self):
        # two threads for entering and getting a message.
        # it will enable each node to be able to
        # enter a message and still be able to receive a message
        Thread(target=self.input_message).start()
        Thread(target=self.receive_message).start()

I think you can make your code better by making the following changes:

• Some of the comments are kind of useless. The code is more or less self explanatory. For example the comment in the following piece of code is useless:

  # remove the node which the message has been sent to
  # from the list of susceptible nodes and
  # add it to the list of infected nodes
  self.susceptible_nodes.remove(selected_port)
  GossipNode.infected_nodes.append(selected_port)
  

  Here the comments are making the code less readable.

• The following comment is also useless since sendto function's definition clearly says when it is used.

  # since we are using connectionless protocol,
  # we will use 'sendto' to transmit the UDP message
  

• Also try writing shorter comments. You can usually skip the logic behind using the function in the comments, unless it is like a very important part of your code and is not clear from the function name.

• Instead of using different code for different machines, use a single code. Save the port information in a separate file and read the port from that file.

  from Gossip import GossipNode
  FILE_NAME = "randomFile.txt"
  port = read_port(FILE_NAME)
  connected_nodes = [5010]
  …
  

I am also removing the comments from this code. It is clear from the code what you are trying to do and the comments are not adding any useful information.

Outside of refining the documentation - docstrings, comments, and type hints - I'd suggest:

Improving input and output

Some of your prints seem more suitable for a logger (logging). For example print("Susceptible nodes =>", self.susceptible_nodes), which could be an info or debug level log message - something like logger.debug(f"{self.susceptible_nodes=}").

I'd also switch to using f-strings in general for readability, and to avoid manually styling text (e.g. print("\n") and print("-"*50)).

Create a node manager

Instead of manually keeping track of your nodes and which ports they use, you could create a class that does this. You'd just store a list of GossipNodes, and then you can optionally check if the port is free, and even make port an optional argument (you'd automatically find an available port if that argument isn't passed).

Offer a way out of the NoReturns (the infinite loops)

Instead of just having a blank while True, you could have e.g.

try:
    while True:
        # loop
except KeyboardInterrupt:
    # exit