Real time Python via TCP (Part I)

TL;DR

From this post, you’ll learn how to implement asynchronous echo TCP Server & Client using Tornado framework. All code is on GitHub.

Roadmap

1. It’s the first post in the series and is devoted to building simple echo TCP Server in Tornado to show implementation details and coroutine usage.
2. In the next post, we’ll take a closer look at how to connect Tornado to Redis PUB/SUB mechanism in order to deliver data updates in real time.
3. The final part will cover the implementation of the simple protocol that can control client-server interaction.

Background

As the Real Time Web is fully in its power nowadays more and more applications need improved sophisticated interaction mechanisms between the server and clients. Notifications, live chats, streamline data are common examples of so-called “real time” interactions where the server is not only responsible for receiving requests from clients and serving them but generates its own activity towards the clients.

All of these features are possible, thanks to Push technology. One of the more popular ways of implementing it nowadays is WebSockets protocol. It’s very similar to HTTP and provides bidirectional connectivity between server and client.

As described in the docs:

The WebSocket Protocol is an independent TCP-based protocol. Its only relationship to HTTP is that its handshake is interpreted by HTTP servers as an Upgrade request.

So, after all, it’s just a special kind of TCP connection with certain agreements on how server and client behave.

The solution I’m going to describe here is a little bit different. I suggest using raw TCP protocol so we can play around the lower level stuff and also learn how to use Push connectivity in the environments where WebSockets aren’t available. It also might be a tiny bit faster than using WebSocket, although I’d not account on that since experiments show that WebSockets are damn optimized.

Echo TCP Server

So let’s kick this off by implementing a simple TCP echo server that just listens to the connections on a certain port and responds back with whatever data it receives.

We will use Tornado asynchronous web framework for this task, that is proved to be extremely robust and able to handle tens of thousands of concurrent connections. An alternative solution would be standard Python socketserver framework.

Here’s a quick look at Tornado server: View this code snippet on GitHub.

We subclass tornado.tcpserver.TCPServer here. The only function that needs to be overridden in order to make it work is handle_stream. It takes stream representing client socket connection wrapped in special Tornado object, as well as client address, which is a simple tuple of the form ('127.0.0.1', 55196). The body of the function consists of an infinite loop that reads data from the socket with stream.read_until and responds with the same data back to the client by issuing stream.write call. Sudden shutdown of the socket is by no means an unexpected situation with all the possible ways the connection might be cut (routing error, client closing the application, timeout, etc.). That’s why we clean up the socket resource on our side and just return from the function in such case.

The server launch is also something worth mentioning: View this code snippet on GitHub.

The server starts working when the IOLoop instance spins up and begins to process submitted coroutines. After IOLoop has exited the whole program finishes.

The client code is simpler: View this code snippet on GitHub.

Here, we asynchronously connect to the specified socket (host/port pair) and start an infinite loop of waiting for data input from the console, writing this data to the socket and reading back the server response.

Finally, client launch code is similar to server’s: View this code snippet on GitHub.

Now we can launch everything and see how it works.

Start the server:

$ python real_time/server.py
Starting the server...

Start the client:

$ python real_time/client.py
Connecting to server socket...
>> echo me
b'echo me'

You can launch as many clients in separate terminals as you wish and see that everyone receives their own messages back.

Conclusion

Now, the code here isn’t particularly useful on its own, but we’ll go from here and tweak it so we can get some cool functionality.

As mentioned in the beginning, the code for this Echo Server/Client is on GitHub, clone, fork, try running and play with it yourself. That’s all for now. Don’t brawl, stay calm.

References

1. Push Technologies
   1. wikipedia.org: Push technology
   2. stackoverflow.com: What are Long-Polling, Websockets, Server-Sent Events (SSE) and Comet?
   3. medium.com: Python and Server-sent Event
   4. fullstackpython.com: WebSockets
   5. ietf.org: WebSockets RFC
2. Python TCP
   1. docs.python.org: socket.py
   2. docs.python.org: socketserver.py
   3. tornadoweb.org: Tornado framework
   4. pymotw.com: TCP/IP Client and Server
   5. binarytides.com: Code a simple socket server in Python
   6. curiousefficiency.org: TCP echo client and server in Python 3.5
   7. gist.github.com: Simple example of creating a socket server with Tornado

History

• 2^nd June, 2018: Initial version