Program structure using asyncio

Question

I currently have a program structured like this:

set_up_everthing()

while True:
    if new_client_ready():
        connect_new_client()

    for client in clients:
        if client.is_ready():
            get_input_from(client)

    update_program_state_based_on_input()

    for client in clients:
        if client.is_ready():
            send_output_to(client)

clean_up()

The network I/O currently uses sockets and select, but I want to rewrite it to use the asyncio library. I think I understand how to make a simple asyncio program, the idea seems to be that when you want to do some I/O, you yield from a function that does it, so when the main loop gets a new client, it does yield from accept_client(), and when that client receives information it does yield from read_information(), and so on. However, I can't work out how to combine this with other parts of the program.

here's a simple but complete port forwarder implementation using asyncio. — jfs
– jfs, Commented Dec 27, 2014 at 7:33

l04m33 · Accepted Answer · 2015-05-20 03:10:02Z

3

The asyncio module has two levels of APIs: The low-level transports & protocols API and the high-level streams API. They are like different frameworks. Depending on the API level you are using, your program structure may differ dramatically.

To prevent yourself from going crazy, normally you don't want to mix these two levels of APIs.

The two levels differ in that you receive data in different ways. The low-level API provides an event-driven interface, your program responds to incoming events by implementing callbacks - The framwork calls your code. The high-level API have a nicer look, in that it provides readers & writers, and your code calls the framework.

The examples in asyncio docs should be easy enough to follow.

answered May 20, 2015 at 3:10

l04m33

6064 silver badges12 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Zearin Over a year ago

Thank you! A very helpful answer, expressed simply and concisely.

DanielSank Over a year ago

The stream and protocol styles aren't that different. The key if you use protocols is that you may need to make an asynchronous request while handling incoming data, so you have to create_task so that your data handling code can be a coroutine. You also have to know how to wake up a suspended task when data is ready, e.g. because your remote peer answered a request.

Andrew Svetlov · Accepted Answer · 2014-12-26 19:30:14Z

2

Your snippet roughly describes how asyncio works itself.

Please take a look on asyncio example for how to use asyncio:

import asyncio

@asyncio.coroutine
def echo_server():
    yield from asyncio.start_server(handle_connection, 'localhost', 8000)

@asyncio.coroutine
def handle_connection(reader, writer):
    while True:
        data = yield from reader.read(8192)
        if not data:
            break
        writer.write(data)

loop = asyncio.get_event_loop()
loop.run_until_complete(echo_server())
try:
    loop.run_forever()
finally:
    loop.close()

answered Dec 26, 2014 at 19:30

Andrew Svetlov

17.5k8 gold badges70 silver badges72 bronze badges

Collectives™ on Stack Overflow

Program structure using asyncio

2 Answers 2

2 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related