add support for async.callback api about puma

[rkh]

What needs to be done to fully support the async API currently used by Thin, Rainbows!, Zbatery and Ebb:

• wrap the app.call in a catch(:async) and treat it like status -1 (status -1 is essentially not usable, as Rack::Lint and other middleware will go berserk if they see it)
• add env['async.callback'] which is a proc (or anything responding to call) for setting status code, headers, and body object
• if the body object responds to callback and errback, don't close the connection after being done with the each call, instead call those methods with a block for closing the connection (i.e. body.callback { connection.close })
• add env['async.close'] which responds to callback and errback. these methods store the blocks passed to it and trigger them if the connection is being closed (for instance by the client)
• make sure the block passed to each can be called at any later point in time (before the connection has been closed) and will still send out the message to the client

An example Rack application using this protocol could look like this:

class Body
  def <<(msg)
    @each[msg] if @each
  end

  # close is reserved by the rack spec
  def close!
    @callback.call
  end

  def each(&block)
    @each = block
  end

  def callback(&block)
    @callback = block
  end

  alias errback callback
end

require 'sinatra'
streams = []

get '/' do
  stream = Body.new
  streams << stream
  env['async.close'].callback { streams.delete(stream) }
  stream
end

post '/' do
  streams.each { |stream| stream << params[:message] }
  [201, 'message send']
end

delete '/' do
  streams.each(&:close!)
  streams.clear
  'closed all connections'
end

This is just for demo reasons (i.e. I didn't run the code, it's obviously not thread-safe, etc). A proper implementation can be found in this example or within Sinatra (used for instance in a real time chat example).

I'm super swamped with work at the moment, but might be able to implement this (if no one else takes care of it) once we've released pre-tested Pull Requests for Travis CI.

[Nerian]

@evanphx Is there an example somewhere I can read about how to do async calls with puma?

[jimsynz]

Keen to help with this.

[evanphx]

Part of this has been added by having puma understand the async response pattern to abandon handling of the socket.

[evanphx]

@rkh So, I looked at what how sinatra used the API and was put off by this: https://github.com/sinatra/sinatra/blob/f2bc346a3c56d61d744fb4419623befc47a7bc65/lib/sinatra/base.rb#L342

Doesn't that imply that sinatra assumes that if async.callback is set, then EventMachine is being used?

[rkh]

Yeah, I can "fix" that. But otherwise streaming doesn't work on EventMachine based servers (which all the servers supporting async.callback are atm).

[iostat]

Hi! Has anybody been working on this? If not, I might be able to help out sometime in the future.

[evanphx]

None is currently working on it, no.

Evan Phoenix // [email protected]

On Wednesday, April 10, 2013 at 7:18 AM, Ilya Ostrovskiy wrote:

Hi! Has anybody been working on this? If not, I might be able to help out sometime in the future.

—
Reply to this email directly or view it on GitHub (#3 (comment)).

[maccman]

Would definitely love to see this.

[lucaong]

Was this closed because the feature was discarded, or because a better strategy to support async request handling is/will be available?

[evanphx]

Mostly because Puma already has support and Sinatra needs to figure out how to manage async.callback when EventMachine isn't used.

[axos88]

I'd love to see an example on usage as well