Making moves w/ websockets and python / django ( / twisted? )

by

I’m the author of django-websocket. I’m not a real expert in the topic of websockets and networking, however I think I have a decent understanding of whats going on. Sorry for going into great detail. Even if most of the answer isn’t specific to your question it might help you at some other point. 🙂

How websockets work

Let me explain shortly what a websocket is. A websocket starts as something that really looks like a plain HTTP request, established from the browser. It indicates through a HTTP header that it wants to “upgrade” the protocol to be a websocket instead of a HTTP request. If the server supports websockets, it agrees on the handshake and both – server and client – now know that they will use the established tcp socket formerly used for the HTTP request as a connection to interchange websocket messages.

Beside sending and waiting for messages, they have also of course the ability to close the connection at any time.

How django-websocket abuses the python’s wsgi request environment to hijack the socket

Now lets get into the details of how django-websocket implements the “upgrading” of the HTTP request in a django request-response cylce.

Django usually uses the WSGI specification to talk to the webserver like apache or gunicorn etc. This specification was designed just with the very limited communication model of HTTP in mind. It assumes that it gets a HTTP request (only incoming data) and returns the response (only outgoing data). This makes it tricky to force django into the concept of a websocket where bidirectional communication is allowed.

What I’m doing in django-websocket to achieve this is that I dig very deeply into the internals of WSGI and django’s request object to retrieve the underlaying socket. This tcp socket is then used to handle the upgrade the HTTP request to a websocket instance directly.

Now to your original question …

I hope the above makes it obvious that when a websocket is established, there is no point in returning a HttpResponse. This is why you usually don’t return anything in a view that is handled by django-websocket.

However I wanted to stick close to the concept of a view that holds the logic and returns data based on the input. This is why you should only use the code in your view to handle the websocket.

After you return from the view, the websocket is automatically closed. This is done for a reason: We don’t want to keep the socket open for an undefined amount of time and relying on the client (the browser) to close it.

This is why you cannot access a websocket with django-websocket outside of your view. The file descriptor is then of course set to -1 indicating that its already closed.

Disclaimer

I explained above that I’m digging in the surrounding environment of django to get somehow — in a very hackish way — access to the underlaying socket. This is very fragile and also not supposed to work since WSGI is not designed for this! I also explained above that the websocket is closed after the view ends – however after the websocket closed down (AND closed the tcp socket), django’s WSGI implementation tries to send a HTTP response – it doesn’t know about websockets and thinks it is in a normal HTTP request-response cycle. But the socket is already closed an the sending will fail. This usually causes an exception in django.

This didn’t affected my testings with the development server. The browser will never notice (you know .. the socket is already closed 😉 – but raising an unhandled error in every request is not a very good concept and may leak memory, doesn’t handle database connection shutdown correctly and many athor things that will break at some point if you use django-websocket for more than experimenting.

This is why I would really advise you not to use websockets with django yet. It doesn’t work by design. Django and especially WSGI would need a total overhaul to solve these problems (see this discussion for websockets and WSGI). Since then I would suggest using something like eventlet. Eventlet has a working websocket implementation (I borrowed some code from eventlet for the initial version of django-websocket) and since its just plain python code you can import your models and everything else from django. The only drawback is that you need a second webserver running just to handle websockets.

More Related Contents:

  1. Send message using Django Channels from outside Consumer class
  2. Does the django-rest-framework provide an admin site to manage models?
  3. How to convert JSON data into a Python object?
  4. Django filter queryset __in for *every* item in list
  5. Django, creating a custom 500/404 error page
  6. How to set timeout on python’s socket recv method?
  7. How do I force Django to ignore any caches and reload data?
  8. socket.shutdown vs socket.close
  9. Django: Adding “NULLS LAST” to query
  10. Serving dynamically generated ZIP archives in Django
  11. How can I save my secret keys and password securely in my version control system?
  12. many-to-many in list display django
  13. How to filter (or replace) unicode characters that would take more than 3 bytes in UTF-8?
  14. Sending a reset in TCP/IP Socket connection
  15. Running Sudo Command with paramiko
  16. Calling a REST API from django view
  17. find_element_by_class_name for multiple classes [duplicate]
  18. Django – makemigrations – No changes detected
  19. Django Rest Framework – How to add custom field in ModelSerializer
  20. DateTimeField doesn’t show in admin system
  21. Django 1.11 TypeError context must be a dict rather than Context
  22. Python socket.error: [Errno 111] Connection refused
  23. How do I filter values in a Django form using ModelForm?
  24. Django cannot import login from django.contrib.auth.views
  25. django filter on the basis of text length
  26. Django vs other Python web frameworks?
  27. How to use csrf_token in Django RESTful API and React?
  28. Django: Serving Media Behind Custom URL
  29. How to annotate Count with a condition in a Django queryset
  30. Multiple lookup_fields for django rest framework

Leave a Comment