This is just a short blog post that trying to talk about the timeout thingy. Continuing the previous post, implementing Stop-and-Wait flow control requires you to... well.... stop and wait.

Bruh.

If we're talking about JavaScript, it's all sunshine and rainbow as we can just go with something as simple as:

setTimeout(callback, timer);

Just specify what you want to do in the callback function, and then you're done. In case you want to prevent the function to be called, probably because you don't want it to be called, you can just place a handler for the timeout function.

let handler = setTimeout(() => {
  alert('a');
}, 1000);
// then something happened that you dont want to call the alert function specified before
// just go with
clearTimeout(handler);

Something as simple as this is achieved using JavaScript clever Event Loop, which creates a pseudo-asynchronous flow. It's not really an asynchronous flow, as it's still tied with the nature of JavaScript being single-threaded.

~~Just like my heart~~

Now, talking about other language that have close relationship with the operating system, asynchronous task can be achieved by using two common methods: Forking/Spawning child process, or Multithreading. Forking/Spawning child process is considered "costly" because it literally creates another process, with their own process ID. Not really ideal for our simple application.

So this is the part where we introduce threading.

But is this the case where we need to actually introduce multithreading in our Python app? Turns out, the thing we're handling right now (socket) already have a very handy method, called "settimeout"

Yes. As simple as that. God bless the designer for knowing our struggles. Latom

socket.settimeout()

When you create a socket object, you're exposed to several methods to configure the behavior of the socket. Setting up a socket connection, in particularly for UDP, can go as simple as:

from socket import socket
# Creating the socket
sock = socket(socket.AF_INET, socket.SOCK_DGRAM)
# Listening to incoming data transmission on localhost at port 5000
sock.bind(('127.0.0.1', 5000))

Most people would just go with that. And it's pretty fine when you're testing it on local. I mean, communicating with yourself assure that there is 0% packet loss, and it goes lighting fast!

Of course the real world scenario doesn't go like that!

Talking about the behavior of UDP, which is connectionless, it's just the same as throwing a rock. You just throw, then have no idea whether you hit it or not. Of course this is not reliable.

Stop-and-wait flow control manage to fix this by creating an agreement, that if by a certain time there is no 'news' about the other side, this side is going to ask again about the 'news' about the other side. It's just a way to assure whether the peer is still 'alive' or probably dead. This is implemented by setting a timeout, so if there is no 'news' after waiting for a certain amount of time, we can do something in order to "wake up" the situation yet again.

The usage is simple. Just set the timeout by calling

socket.settimeout(value)
# value is in second

This is usually paired with "socket.recvfrom()" because we're waiting for an info about the other side, so we need to receive something from the other side. If we get something, then nothing to worry about the timeout. But if we don't get something, then an error will be thrown. Wrapping with try-except block, it goes like:

socket.settimeout(value)
try:
  socket.recvfrom(amount_to_receive)
except socket.Timeout: #handles Timeout error object# do the error handling here

Pairing this with a simple looping, you can achieve the most simple stop-and-wait protocol. Simplified in this snippet:

socket.settimeout(1)
while i < len(packets_to_send):
  try:
    socket.recvfrom(amount_to_receive)
    i += 1 # increment to send next packet# another stuff to doexcept socket.Timeout: #oh no it's timeout# error handling# NOTE : don't increment i because we want to keep sending# the same packet until acknowledgement arrives

In this way, the most simple Stop-and-wait flow control can be achieved. Adding stuff like data processing, then you're done.

As I'm implementing my app, things went a little bit more complicated as the attempt to optimize memory usage and disk usage still continues. Below is snippet from my own implementation

def send_file(self):
        # this is where things start to escalate real quickly
        # implement using Stop-and-Wait protocol
        seqnum = 0
        self.socket.settimeout(1)
        while seqnum != len(self.packets_queue):
            # send a packet
            if seqnum != len(self.packets_queue) - 1:
                # print("Sending packet with seqnum : ", seqnum, bytes2hexstring(self.packets_queue[seqnum].data))
                self.send_packet(self.packets_queue[seqnum])
                # start timeout
                # if packet arrives, increment seqnum
                try:
                    response, server_address = self.socket.recvfrom(2 << 16)
                    received_packet = PacketUnwrapper(response)
                    print("Received seqnum: ", received_packet.seqnum)
                    if received_packet.raw_type == 0x01: #ACK Package
                        if received_packet.seqnum == seqnum:
                            print("ACK packet received, sending next package, if any")
                            seqnum += 1
                except socket.timeout:
                    print("Timeout on sending packet seqnum:", seqnum)
                    print("Re-attempting...")
                except ConnectionResetError:
                    print("Connection reset. Peer is probably not open.")
                # if timeout arrives, do nothing, let the loop goes as to send same packet
            else: # Send FIN package
                try:
                    print("Sending FIN package")
                    # print("Sending packet with seqnum : ", seqnum, bytes2hexstring(self.packets_queue[seqnum].data))
                    self.send_packet(self.packets_queue[seqnum])
                    response, server_address = self.socket.recvfrom(2 << 16)
                    received_packet = PacketUnwrapper(response)
                    print("Received seqnum: ", received_packet.seqnum)
                    if received_packet.raw_type == 0x03:
                        if received_packet.seqnum == seqnum:
                            print("FIN-ACK packet received. Ending the current transmission")
                            seqnum += 1
                except socket.timeout:
                    print("Timeout on sending packet seqnum:", seqnum)
                    print("Re-attempting...")
                except ConnectionResetError:
                    print("Connection reset. Peer is probably not open.")
                # if timeout arrives, do nothing, let the loop goes as to send same packet

This implementation can give a more reliable file transfer as for every packet that got stalled, the attempt to resend still intact.

Good thing is things work as expected as data arrives and written without any data loss or defect. Pretty happy to see this on comparison.

So the only thing that worries me is the case where large object is being sent. Something around 100MB or even 1GB. This is where the memory and disk usage needs to be further optimized (which probably points to the next blog post topic, i hope).

But hey!

A reliable UDP file transfer!

Nice!

Talking about timeouts in UDP