Creating a Simpe Python Web Socket Server

Question

I am trying to implement a simple web sockets server in Python by using this module. For learning purposes, the server should reply with a reversed version of what it received. For example, if the client sends "Hello Server", the server should respond with "revreS olleH". My code is based off the documentation here

Since an example of a consumer() and producer() function/coroutine wasn't provided in the documentation, I took a stab at creating them but think I am misunderstanding something not obvious to me. The code is currently returning the string 'nothing' instead of the reversed version of what the client sent.

FYI, since the machine I am using has Python 3.4.3, the code had to be adjusted to accommodate for that version. That's why you'll see newer code commented out, for now. Lots of documentation is included too as I learn this stuff.

Now, the codez...

index.py:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-



#########################
# Dependencies
#########################
# asyncio
# websockets



#########################
# Modules
#########################

import asyncio
import websockets



#########################
# Functions
#########################

# async indicates an asynchronous function.
# Calling them doesn't actually run them,
# but instead a coroutine object is returned,
# which can then be passed to the event loop to be executed later on.

# Python ≥ 3.5: async def producer(reply):
@asyncio.coroutine
def producer(reply=None):
    """Sends the reply to producer_handler."""

    if reply is None:
        return 'nothing'
    else:
        return reply

# Python ≥ 3.5: async def consumer(message):
@asyncio.coroutine
def consumer(message):
    """Reverses message then sends it to the producer."""

    reply = message[::-1]
    #await producer(reply)
    yield from producer(reply)

# async def consumer_handler(websocket):
@asyncio.coroutine
def consumer_handler(websocket):
    """Handles incoming websocket messages."""

    while True:
        # await calls an asynchronous function.
        #message = await websocket.recv()
        message = yield from websocket.recv()
        # Python ≥ 3.5: await consumer(message)
        yield from consumer(message)

#async def producer_handler(websocket):
@asyncio.coroutine
def producer_handler(websocket):
    """Handles outgoing websocket messages."""

    while True:
        #message = await producer()
        message = yield from producer()
        #await websocket.send(message)
        yield from websocket.send(message)

#async def handler(websocket, path):
@asyncio.coroutine
def handler(websocket, path):
    """Enables reading and writing messages on the same websocket connection."""

    # A Future is an object that is supposed to have a result in the future.

    # ensure_future:
    # schedules the execution of a coroutine object,
    # wraps it in a future, then returns a Task object.
    # If the argument is a Future, it is returned directly.

    # Python ≥ 3.5
    #consumer_task = asyncio.ensure_future(consumer_handler(websocket))
    #producer_task = asyncio.ensure_future(producer_handler(websocket))

    consumer_task = asyncio.async(consumer_handler(websocket))
    producer_task = asyncio.async(producer_handler(websocket))

    # .wait:
    # wait for the Futures and coroutine objects given
    # by the sequence futures to complete. Coroutines will be
    # wrapped in Tasks. Returns two sets of Future: (done, pending).

    #done, pending = await asyncio.wait(
    done, pending = yield from asyncio.wait(
        # The futures.
        [consumer_task, producer_task],
        # FIRST_COMPLETED: the function will return when
        # any future finishes or is cancelled.
        return_when=asyncio.FIRST_COMPLETED,
    )
    for task in pending:
        task.cancel()



#########################
# Start script
#########################

def main():

    # Creates a WebSocket server.
    start_server = websockets.serve(handler, '127.0.0.1', 8000)

    # Get the event loop for the current context.
    # Run until the Future is done.
    asyncio.get_event_loop().run_until_complete(start_server)

    # Run until stop() is called.
    asyncio.get_event_loop().run_forever()



#########################
# Script entry point.
#########################

if __name__ == '__main__':
    main()

index.html:

<!DOCTYPE html>
<html>
    <head>
        <title>WebSocket demo</title>
    </head>
    <body>
        <script>
            // Create the websocket.
            var ws = new WebSocket("ws://127.0.0.1:8000/"),
                messages = document.createElement('ul');

            // Called when the websocket is opened.
            ws.onopen = function(event) {
                ws.send('Hello Server!');
            };

            // Called when a message is received from server.
            ws.onmessage = function(event) {
                var messages = document.getElementsByTagName('ul')[0],
                    message = document.createElement('li'),
                    content = document.createTextNode(event.data);
                message.appendChild(content);
                messages.appendChild(message);
            };
            document.body.appendChild(messages);
        </script>
    </body>
</html>

Answer 1

Not completely sure on this, but I think you misinterpreted the docs. The consumer shouldn't be calling the producer.

The "Hello Server!" the HTML file sends goes through consumer_handler to consumer to producer, but the yield from statements means that the reversed string ends up back in the consumer_handler, as the result of yield from consumer(message).

On the other hand, producer_handler calls producer many times without an argument (from message = yield from producer()), which is what creates the nothing that gets sent to the HTML file. It doesn't receive the consumer's string.

Instead, there should be a queue or something where the consumer pushes to and the producer takes from, like in this example.

Thanks.