12

I'm trying to stream Server-Sent Events from my Pyramid application, but I can't figure out how to stream the response body from my view. Here's the test view I'm using (it totally doesn't implement SSE, it's just to work out the streaming portion):

@view_config(route_name='iter_test')
def iter_test(request):
    import time
    def test_iter():
        i = 0
        while True:
            i += 1
            if i == 5:
                raise StopIteration
            yield str(time.time())
            print time.time()
            time.sleep(1)

    return test_iter()

This produces ValueError: Could not convert return value of the view callable function pdiff.views.iter_test into a response object. The value returned was <generator object test_iter at 0x3dc19b0>.

I've tried return Response(app_iter=test_iter()) instead, which at least doesn't error out, but it doesn't stream the response - it waits until the generator has completed before returning the response to my browser.

I recognize that could simply return a single event per request and allow the clients to reconnect after each event, but I'd prefer to preserve the realtime nature of Server-Sent Events by streaming multiple events from a single request, without the reconnection delay. How can I do this with Pyramid?

spiffytech
  • 6,161
  • 7
  • 41
  • 57

3 Answers3

10

I've found the issue. Turns out my application code is fine, and the problem lies with Waitress and nginx:

  1. Waitress, the default web server Pyramid uses, buffers all output in 18000-byte chunks (see this issue for details).

  2. The source of the problem was hidden from me by nginx, the web server I put in front of my Pyramid application, which also buffers responses.

(1) can be solved by either:

  • Configuring waitress with send_bytes = 1 in your .ini file. This fixes the streaming problem, but makes your entire app super slow. As @Zitrax mentioned, you can recover some speed with higher values, but any value higher than 1 risks messages getting stuck in the buffer.

  • Switching to gunicorn. I don't know whether gunicorn just uses a smaller buffer, or if it behaves better with app_iter, but it worked, and kept my app fast.

(2) can be solved by configuring nginx to disable buffering for your stream routes.

You need to set proxy_buffering off in your nginx conf. This setting applies to sites hosted via proxy_pass. If you're not using proxy_pass you may need a different setting.

  • You may configure nginx to dynamically enable/disable buffering for each response based on request headers, as shown in this question on the topic (a good solution for EventSource/Server-Sent Events)

  • You may alternatively configure this in a location block in your nginx conf. This is good if you're using something besides EventSource and you're not expecting to receive a particular header, or if you are using EventSource, but want to debug the response from a plain browser tab, where you can't send the Accept header in your request.

Community
  • 1
  • 1
spiffytech
  • 6,161
  • 7
  • 41
  • 57
  • I had the same problem and indeed setting send_bytes to 1 worked. However it turned everything horribly slow (I had pages loading in less than 0.5 seconds that after that took > 10s). And I can't switch to gunicorn currently since that is Unix only. A compromise is to set send_bytes to something > 1 and < 18000. In my case 100 worked pretty good. – Zitrax Oct 05 '15 at 14:49
4

I made some tests a while ago, to try Event Source / Server Sent Events. I just tested and it still works fine with Pyramid 1.5a.

@view_config(route_name = 'events')
def events(request):
    headers = [('Content-Type', 'text/event-stream'),
               ('Cache-Control', 'no-cache')]
    response = Response(headerlist=headers)
    response.app_iter = message_generator()
    return response

def message_generator():
    socket2 = context.socket(zmq.SUB)
    socket2.connect(SOCK)
    socket2.setsockopt(zmq.SUBSCRIBE, '')
    while True:
        msg = socket2.recv()
        yield "data: %s\n\n" % json.dumps({'message': msg})

Full example here: https://github.com/antoineleclair/zmq-sse-chat. Have a look at https://github.com/antoineleclair/zmq-sse-chat/blob/master/sse/views.py.

I'm not sure exactly why mine works and not yours. Maybe it's the headers. Or the two '\n' after each message. By the way, if you look at the event source spec correctly, you have to prefix each new event by data: and use \n\n as event separator.

Antoine Leclair
  • 17,540
  • 3
  • 26
  • 18
  • Thank you! Knowing that my approach should definitely work pointed me towards other potential problems, which lead me to the solution. – spiffytech Feb 04 '14 at 00:25
  • This no longer work. It must not return bytes so use `yield "data: %s\n\n" % json.dumps({'message': msg}).encode()` – Pierre Thibault Feb 21 '20 at 14:33
2

If you don't specify any renderer for your view, you have to return a Response object. Pyramid Response object has a special argument app_iter for returning iterators. So you should do that in this way:

import time
from pyramid.response import Response


@view_config(route_name='iter_test')
def iter_test(request):

    def test_iter():
        for _ in range(5):
            yield str(time.time())
            print time.time()
            time.sleep(1)

    return Response(app_iter=test_iter())

I also edited your code a little to be more readable.

UPDATE

I've tried return Response(app_iter=test_iter()) instead, which at least doesn't error out, but it doesn't stream the response - it waits until the generator has completed before returning the response to my browser.

I guess the problem is in buffering. Try to send a really big iterator.

Dmitry Vakhrushev
  • 1,382
  • 8
  • 12
  • In my tests, `app_iter` isn't streamed to the browser. Rather, webob runs the iterator to completion before returning the results (relevant webob code is here: [github](https://github.com/Pylons/webob/blob/c6c08966bc18b83f194e9d4bde6f77d43d951e09/webob/response.py#L345)). For EventSource streams to work properly, my iterator needs to be infinite (i.e., not readily run to completion), and results need to be passed to the browser as they are generated, rather than in one big lump. – spiffytech Feb 02 '14 at 14:48
  • @spiffytech The code you linked is "body" getter, which really collapses "app_iter" into single string. But WebOb doesn't do that: see code of [__call__](https://github.com/Pylons/webob/blob/c6c08966bc18b83f194e9d4bde6f77d43d951e09/webob/response.py#L1014) method. I didn't check Pyramid sources, but I guess it doesn't do that too. So if you return a Response object with "app_iter" and don't access "body" in your code, WebOb will return "app_iter" as it is. – Dmitry Vakhrushev Feb 02 '14 at 19:28
  • Buffering doesn't look like the problem - I tried a much larger generator (50k items), and Pyramid still waited until it was complete to send the results. Regardless, I need to not wait - the point of Server-Set Event streams is that the events come to the browser immediately, so I can't wait for a buffer to fill up. Also, the section of webob's code I linked to is actually getting called - I got that line number by setting a breakpoint inside my iterator and looking at the callstack while the iterator was running, using code above - no access to body, and the appropriate Response object. – spiffytech Feb 02 '14 at 21:46