ione-rpc 1.0.0.pre0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 80f4a0fbab22cefd0de19d54c779637b15129ea8
+  data.tar.gz: 35d701df7cba437f67fb5fd505b457d49d43ad7c
+SHA512:
+  metadata.gz: ea81e63e8b59f31ac42b60be6e432480a365efa8f7de7da8475eb99acf8877445045e93c77634d14d9eb717cf9e4301b7c0bee2b82dc0366a3bd381b2b61e47e
+  data.tar.gz: a2384cb4793ed2dbbe7a344ee535d74844d386b94ff531aa0abad4a12ed1b5cc30461a90ca90cbdd787b761e1ee31b3936665f8c9ef164928387d02354571bc0

data/.yardopts

@@ -0,0 +1,5 @@
+--no-private
+--protected
+--markup markdown
+lib/**/*.rb
+-- README

data/README.md

@@ -0,0 +1,267 @@
+# Ione RPC framework
+
+[![Build Status](https://travis-ci.org/iconara/ione-rpc.png?branch=master)](https://travis-ci.org/iconara/ione-rpc)
+[![Coverage Status](https://coveralls.io/repos/iconara/ione-rpc/badge.png)](https://coveralls.io/r/iconara/ione-rpc)
+[![Blog](http://b.repl.ca/v1/blog-ione-ff69b4.png)](http://architecturalatrocities.com/tagged/ione)
+
+_If you're reading this on GitHub, please note that this is the readme for the development version and that some features described here might not yet have been released. You can find the readme for a specific version either through [rubydoc.info](http://rubydoc.info/find/gems?q=ione-rpc) or via the release tags ([here is an example](https://github.com/iconara/ione-rpc/tree/v1.0.0))._
+
+Ione RPC is a framework for writing server and client components for your Ruby applications. You need to write the request handling logic, but the framework handles most of the hard things for you – including automatic reconnections, load balancing, framing and request multiplexing.
+
+# Installing
+
+There is currently no gem release of Ione RPC, but you can install it from git with Bundler:
+
+```ruby
+# in Gemfile
+gem 'ione-rpc', github: 'iconara/ione-rpc'
+```
+
+# Example
+
+To communicate the client and the server need to agree on how messages should be encoded. In Ione RPC the client and server need a _codec_ which they will use to encode and decode messages. The easiest way to create a codec is to use `Ione::Rpc::StandardCodec` which takes an object that conforms to the (more or less) standard Ruby encoder protocol that libraries like JSON, YAML, MessagePack and others implement: `#dump` for encoding, `#load` for decoding (technically it's `.dump` and `.load`, but it depends on the perspective).
+
+`StandardCodec` is stateless, so you can assign your codec to a constant:
+
+```ruby
+CODEC = Ione::Rpc::StandardCodec(JSON)
+```
+
+Using JSON for encoding isn't the most efficient, but you can easily change to MessagePack when needed, or write a little bit more code and use something like [Protocol Buffers](https://code.google.com/p/protobuf/).
+
+### A server
+
+When we have a codec the next step is to create the server component. Servers need to implement the `#handle_request` method, and return a future with the response.
+
+```ruby
+class TranslateServer < Ione::Rpc::Server
+  def initialize(port)
+    super(port, MY_CODEC)
+  end
+
+  def handle_request(request, _)
+    case request['message']
+    when 'Hello world'
+      Ione::Future.resolved('translation' => 'Hallo welt')
+    else
+      Ione::Future.resolved('error' => 'Entschuldigung, ich verstehe nich')
+    end
+  end
+end
+```
+
+It might seem like unnecessary overhead to have to create a future when you just want to return a response – but think of the possibilities: the request handling can be completely asynchronous. Your server will most likely just transform the request into one or more requests to a database, or other network services, and if they are handled asynchronously your server will use very few resources and be able to process lots of requests.
+
+Please note that you must absolutely not do any blocking operations in `#handle_request` as they would block the whole server.
+
+When you have your server class you need to instantiate it and start it:
+
+```ruby
+server = TranslateServer.new(3333)
+started_future = server.start
+started_future.on_value do |s|
+  puts "Server running on port #{s.port}"
+end
+```
+
+Servers can implement a method called `#handle_connection` to get notified when a client connects – this can be used create some kind of per-connection state, for example – and there are some options that can be set to control low level network settings, but apart from that, but most of the time the code you see above is all that is required.
+
+The server will run in a background thread. If your application is just the server you need to make sure that the main application thread doesn't exit, because that means that the process will exit and the server stops. You can call `sleep` with no argument to put the main thread to sleep forever. The application will still exit when `kill`ed, on ctrl-C, or when you call `Kernel.exit`.
+
+### A client
+
+The client is even simpler than the server. In its simplest form this is all you need:
+
+```ruby
+client = Ione::Rpc::Client.new(CODEC, hosts: %w[node1.example.com:3333 node2.example.com:3333])
+```
+
+You can give the client a list of a single host, or many, it will connect to them all and randomize which one to talk to for each request. When a connection is lost the client will automatically try to reconnect, but use the other connections for requests in the meantime.
+
+You can add more hosts with `#add_host` and you can tell the client to disconnect from a host (or stop trying to reconnect) with `#remove_host`.
+
+To send requests you need to start your client, and then use `#send_request`:
+
+```ruby
+started_future = client.start
+started_future.on_value do
+  response_future = client.send_request('message' => 'Hello world')
+  response_future.on_value do |response|
+    puts response['translation']
+  end
+end
+```
+
+The client takes care of encoding your request into bytes and send them over the network to the server, wait for the response, decode the response and deliver it back to your code.
+
+Maybe you got a bit of a yucky feeling when you read the code above? Did it remind you of the callback hell from Node.js? Everything in Ione RPC that is not instantaneous returns a future. Futures are more pleasant to work with than callbacks, because they compose, so let's rewrite it to take advantage of the combinatorial powers of futures:
+
+```ruby
+response_future = client.start.flat_map do |client|
+  client.send_request('message' => 'Hello world')
+end
+translation_future = response_future.map do |response|
+  response['translation']
+end
+translation_future.on_value do |translation|
+  puts translation
+end
+```
+
+That's better. It's still callbacks, of sorts, but these compose. `Ione::Future#flat_map` lets you chain asynchronous operations together and get a future that is the result of the last operation. `Ione::Future#map` is the non-asynchronous version that just transforms the result of a future to something else, just like `Array#map`.
+
+If any of the operations in the chain fail the returned future fails and the operations after the failing one are never performed. There's a more complex example of working with futures further down.
+
+If you don't care about being asynchronous you can use `Ione::Future#value` to wait for the result of a future to be available:
+
+```ruby
+client.start.value
+response = client.send_request('message' => 'Hello world').value
+puts response['translation']
+```
+
+If you choose to do it the asynchronous way just remember to not do any blocking operations (like calling `#value` on a future) in methods like `#flat_map`, `#map` or `#on_value`. Doing that will block the whole IO system and can lead to very strange bugs.
+
+# A more advanced client
+
+As you saw above you don't need to create a client class, but if you do there's some more features you can use.
+
+First of all creating a client class means that you can hide the shape of the messages and present a higher level interface:
+
+```ruby
+class TranslationClient < Ione::Rpc::Client
+  def initialize(hosts)
+    super(CODEC, hosts: hosts)
+  end
+
+  def translate(message)
+    send_request('message' => message)
+  end
+end
+```
+
+If you read the part above about how the client randomly selected which server to talk to and though that that wasn't very useful, there's a way to override that, just implement `#choose_connection`:
+
+```ruby
+class TranslationClient < Ione::Rpc::Client
+  def initialize(hosts)
+    super(CODEC, hosts: hosts)
+  end
+
+  def translate(message)
+    send_request('message' => message, 'routing_key' => message.hash)
+  end
+
+  def choose_connection(connections, request)
+    connections[request['routing_key'] % connections.size]
+  end
+end
+```
+
+The `#choose_connection` method lets you decide which connection to use for each request. In this example the connection is selected based on the hash of the message, which means that every time the message "Hello world" is sent it will be sent to the same server, but other messages will be sent to others. It doesn't say _which_ server to choose, just that it should always be the same. The connection objects implement `#host` and `#port` so if you want to do routing that picks a specific server that's possible too.
+
+As mentioned above, when a server goes down the client will try to reconnect to it. By default it will try to reconnect forever, at decreasing intervals (up to a max which by default is around a minute), or until you call `#remove_host`. You can control how many times the client will try to reconnect by implementing `#reconnect?`:
+
+```ruby
+class TranslationClient < Ione::Rpc::Client
+  # ...
+
+  def reconnect?(host, port, attempts)
+    attempts < 5
+  end
+```
+
+The method gets the host and port and the number of attempts, and if you return false the reconnection attempts will stop and the host/port combination will be removed, just as if you called `#remove_host`.
+
+Sometimes you implement a protocol that requires the client to send a "startup" message, something that initializes the connections, a hello from the client if you will. You can do this manually, but there's also a special hook for that:
+
+```ruby
+class TranslationClient < Ione::Rpc::Client
+  # ...
+
+  def initialize_connection(connection)
+    send_request({'hello' => {'from' => 'me'}}, connection)
+  end
+end
+```
+
+`#initialize_connection` gets the newly established connection as argument and must return a future that resolves when the connection has been properly initialized. You can use the special form of `#send_request` that takes a second argument to send a requets on a specific connection – this is very important, otherwise your initialization message could be sent over another connection, which wouldn't be very useful.
+
+# Working with futures
+
+```ruby
+all_done_future = update_user_awesomeness('sue@example.com', 8)
+all_done_future.on_value do
+  puts 'All done'
+end
+
+# ...
+
+def update_user_awesomeness(email, new_awesomeness_level)
+  posts_future = @db.execute('SELECT id FROM posts WHERE author = ?', email)
+  # #flat_map composes two asynchronous operations, it returns immediately with a new
+  # future that resolves only when the whole chain of operations is complete.
+  # In other words: the block below will not run now, but when there is a result
+  # from the database query. The future that is returned *represents* the result
+  # of the chain of operations performed on the initial result from the database.
+  posts_future.flat_map do |result|
+    # Don't confuse the #map below with Future#map, this is just a regular
+    # Array#map, transforming each row from the database query into something new.
+    update_futures = result.map do |row|
+      # Each row is used to send another database query, which returns another
+      # future, so the result of this #map block will be an array of futures.
+      update_post_awesomeness(row['id'], new_awesomeness_level)
+    end
+    # The database queries launched in the #map block will all execute in parallel
+    # but we want to know when all of them are done. For this we can use Future.all,
+    # which (surprise!) returns a new future, but one that resolves when *all* of the
+    # source futures resolve – it lets you converge after launching multiple parallel
+    # operations. Future.all transforms a list of futures of values to a future of a
+    # list of values, or in pseudo types: List[Future[V]] -> Future[List[V]].
+    Ione::Futures.all(*update_futures)
+  end
+  # We end up here almost immediately since the #flat_map doesn't run its block,
+  # until it has to. What we return is the return value from the #flat_map call, which is a
+  # future that will eventually resolve when all of the parallel operations we
+  # launched are done
+end
+
+def update_post_awesomeness(id, new_awesomeness_level, retry_attempts=3)
+  f = @db.execute('UPDATE posts SET awesomeness = ? WHERE id = ?', new_awesomeness_level, row['id'
+  # To handle failure we'll use the complement to #flat_map, which is #fallback. When a
+  # future fails, any chained operations will never happen, but sometimes you want to
+  # try again, or do some other operation when an error occurs. For this you can use
+  # #fallback to transform the failed operation into a successful one.
+  f = f.fallback do |error|
+    # Instead of the result of the parent future we get the error, and we can decide
+    # what to do based on whether or not it is fatal or not.
+    if error.is_a?(TryAgainError) && retry_attempts > 0
+      # In this case we want to try again, so we call the method recursively
+      # and decrement the number of remaning retries. This will make sure
+      # that we don't try forever, it's usually a bad idea to never give up.
+      update_post_awesomeness(id, new_awesomeness_level, retry_attempts - 1)
+    else
+      # If you can't recover from the error you can just raise it again and it will be
+      # as if you didn't do anything.
+      raise error
+    end
+  end
+  f
+end
+```
+
+Please refer to [the `Ione::Future` documentation](http://rubydoc.info/gems/ione/frames) for the full story on futures. Coincidentally the code above is more or less how [cql-rb](https://github.com/iconara/cql-rb), the Cassandra driver where Ione came from, works internally (everything but the `TryAgainError`).
+
+# How to contribute
+
+[See CONTRIBUTING.md](CONTRIBUTING.md)
+
+# Copyright
+
+Copyright 2014 Theo Hultberg/Iconara and contributors.
+
+_Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License You may obtain a copy of the License at_
+
+[http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)
+
+_Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License._

data/lib/ione/rpc/client.rb

@@ -0,0 +1,302 @@
+# encoding: utf-8
+
+module Ione
+  module Rpc
+    # This is the base class of client peers.
+    #
+    # You can either create a subclass and add your own high-level convenience
+    # methods for constructing and sending your custom requests, or you can
+    # create a standalone client object and call {#send_request}.
+    #
+    # A subclass may optionally implement {#initialize_connection} to send a
+    # message immediately on a successful connection, and {#choose_connection}
+    # to decide which connection to use for a request.
+    #
+    # The client will handle connections to multiple server peers, and
+    # automatically reconnect to them when they disconnect.
+    class Client
+      # Create a new client with the specified codec and options.
+      #
+      # @param [Object] codec the protocol codec to use to encode requests and
+      #   decode responses. See {Ione::Rpc::Codec}.
+      # @param [Hash] options
+      # @option options [Array<String>] :hosts the host (and ports) to connect
+      #   to, specified either as an array of host (String) and port (Integer)
+      #   pairs (e.g. `[['host1', 1111], [`host2`, 2222]]`) or an array of
+      #   strings on the format host:port (e.g. `['host1:1111', 'host2:2222']`).
+      # @option options [Ione::Io::IoReactor] :io_reactor use this option to
+      #   make the client use an existing IO reactor and not create its own.
+      #   Please note that {#stop} will still stop the reactor.
+      # @option options [Integer] :connection_timeout (5) the number of seconds
+      #   to wait for connections to be established before failing.
+      # @option options [Integer] :max_channels (128) the maximum number of
+      #   channels supported for each connection.
+      # @option options [Logger] :logger a logger conforming to the standard
+      #   Ruby logger API that will be used to log significant events like
+      #   request failures.
+      def initialize(codec, options={})
+        @codec = codec
+        @lock = Mutex.new
+        @connection_timeout = options[:connection_timeout] || 5
+        @io_reactor = options[:io_reactor] || Io::IoReactor.new
+        @max_channels = options[:max_channels] || 128
+        @logger = options[:logger]
+        @hosts = []
+        @connections = []
+        Array(options[:hosts]).each { |h| add_host(*h) }
+      end
+
+      # A client is connected when it has at least one open connection.
+      def connected?
+        @lock.synchronize { @connections.any? }
+      end
+
+      # Start the client and connect to all hosts. This also starts the IO
+      # reactor if it was not already started.
+      #
+      # The returned future resolves when all hosts have been connected to, and
+      # if one or more fails to connect the client will periodically try again,
+      # and the future will not resolve until all of them have connected.
+      #
+      # @return [Ione::Future<Ione::Rpc::Client>] a future that resolves to the
+      #   client when all hosts have been connected to.
+      def start
+        @io_reactor.start.flat_map { connect_all }.map(self)
+      end
+
+      # Stop the client and close all connections. This also stops the IO
+      # reactor if it has not already stopped.
+      #
+      # @return [Ione::Future<Ione::Rpc::Client>] a future that resolves to the
+      #   client when all connections have closed and the IO reactor has stopped.
+      def stop
+        @lock.synchronize { @connections = [] }
+        @io_reactor.stop.map(self)
+      end
+
+      # Add an additional host to connect to. This can be done either before
+      # or after the client is started.
+      #
+      # @param [String] hostname the host to connect to, or the host:port pair (in
+      #   which case the port parameter should be `nil`).
+      # @param [Integer] port the host to connect to, or `nil` if the host is
+      #   a string on the format host:port.
+      # @return [Ione::Future<Ione::Rpc::Client>] a future that resolves to the
+      #   client when the host has been connected to.
+      def add_host(hostname, port=nil)
+        hostname, port = normalize_address(hostname, port)
+        promise = nil
+        @lock.synchronize do
+          _, _, promise = @hosts.find { |h, p, _| h == hostname && p == port }
+          if promise
+            return promise.future
+          else
+            promise = Promise.new
+            @hosts << [hostname, port, promise]
+          end
+        end
+        if @io_reactor.running?
+          promise.observe(connect(hostname, port))
+        end
+        promise.future.map(self)
+      end
+
+      # Remove a host and disconnect any connections to it. This can be done
+      # either before or after the client is started.
+      #
+      # @param [String] hostname the host to connect to, or the host:port pair (in
+      #   which case the port parameter should be `nil`).
+      # @param [Integer] port the host to connect to, or `nil` if the host is
+      #   a string on the format host:port.
+      # @return [Ione::Future<Ione::Rpc::Client] a future that resolves to the
+      #   client (immediately, this is mostly to be consistent with #add_host)
+      def remove_host(hostname, port=nil)
+        hostname, port = normalize_address(hostname, port)
+        @lock.synchronize do
+          index = @hosts.index { |h, p, _| h == hostname && p == port }
+          if index
+            @hosts.delete_at(index)
+            if (connection = @connections.find { |c| c.host == hostname && c.port == port })
+              connection.close
+            end
+          end
+        end
+        Future.resolved(self)
+      end
+
+      # Send a request to a server peer. The peer chosen is determined by the
+      # Implementation of {#choose_connection}, which is random selection by
+      # default.
+      #
+      # If a connection closes between the point where it was chosen and when
+      # the message was written to it, the request is retried on another
+      # connection. For all other errors the request is not retried and it is
+      # up to the caller to determine if the request is safe to retry.
+      #
+      # If a logger has been specified the following will be logged:
+      # * A warning when a connection has closed and the request will be retried
+      # * A warning when a request fails for another reason
+      # * A warning when there are no open connections
+      #
+      # @param [Object] request the request to send.
+      # @param [Object] connection the connection to send the request on. This
+      #   parameter is internal and should only be used from {#initialize_connection}.
+      # @return [Ione::Future<Object>] a future that resolves to the response
+      #   from the server, or fails because there was an error while processing
+      #   the request (this is not the same thing as the server sending an
+      #   error response – that is protocol specific and up to the implementation
+      #   to handle), or when there was no connection open.
+      def send_request(request, connection=nil)
+        connection = connection || @lock.synchronize { choose_connection(@connections, request) }
+        if connection
+          f = connection.send_message(request)
+          f = f.fallback do |error|
+            if error.is_a?(Io::ConnectionClosedError)
+              @logger.warn('Request failed because the connection closed, retrying') if @logger
+              send_request(request)
+            else
+              raise error
+            end
+          end
+          f.on_failure do |error|
+            @logger.warn('Request failed: %s' % error.message) if @logger
+          end
+          f
+        else
+          @logger.warn('Could not send request: not connected') if @logger
+          Future.failed(Io::ConnectionError.new('Not connected'))
+        end
+      rescue => e
+        Future.failed(e)
+      end
+
+      protected
+
+      # Override this method to send a request when a connection has been
+      # established, but before the future returned by {#start} resolves.
+      #
+      # It's important that if you need to send a special message to initialize
+      # a connection that you send it to the right connection. To do this pass
+      # the connection as second argument to {#send_request}, see the example
+      # below.
+      #
+      # @example Sending a startup request
+      #   def initialize_connection(connection)
+      #     send_request(MyStartupRequest.new, connection)
+      #   end
+      #
+      # @return [Ione::Future] a future that resolves when the initialization
+      #   is complete. If this future fails the connection fails.
+      def initialize_connection(connection)
+        Future.resolved
+      end
+
+      # Override this method to implement custom request routing strategies.
+      # Before a request is encoded and sent over a connection this method will
+      # be called with all available connections and the request object (i.e.
+      # the object passed to {#send_request}).
+      #
+      # The default implementation picks a random connection.
+      #
+      # The connection objects have a `#host` property that use if you want to
+      # do routing based on host.
+      #
+      # @example Routing messages consistently based on a property of the request
+      #   def choose_connection(connections, request)
+      #     connections[request.some_property.hash % connections.size]
+      #   end
+      #
+      # @param [Array<Object>] connections all the open connections.
+      # @param [Object] request the request to be sent.
+      # @return [Object] the connection that should receive the request.
+      def choose_connection(connections, request)
+        connections.sample
+      end
+
+      def reconnect?(host, port, attempts)
+        true
+      end
+
+      private
+
+      def connect_all
+        hosts = @lock.synchronize { @hosts.dup }
+        futures = hosts.map do |host, port, promise|
+          f = connect(host, port)
+          promise.observe(f)
+          f
+        end
+        Future.all(*futures)
+      end
+
+      def connect(host, port, next_timeout=nil, attempts=1)
+        if @io_reactor.running?
+          @logger.debug('Connecting to %s:%d' % [host, port]) if @logger
+          f = @io_reactor.connect(host, port, @connection_timeout) do |connection|
+            create_connection(connection)
+          end
+          f.on_value(&method(:handle_connected))
+          f = f.fallback do |e|
+            if connect?(host, port) && reconnect?(host, port, attempts)
+              timeout = next_timeout || @connection_timeout
+              max_timeout = @connection_timeout * 10
+              next_timeout = [timeout * 2, max_timeout].min
+              @logger.warn('Failed connecting to %s:%d, will try again in %ds' % [host, port, timeout]) if @logger
+              ff = @io_reactor.schedule_timer(timeout)
+              ff.flat_map do
+                connect(host, port, next_timeout, attempts + 1)
+              end
+            else
+              @logger.info('Not reconnecting to %s:%d' % [host, port]) if @logger
+              remove_host(host, port)
+              raise e
+            end
+          end
+          f.flat_map do |connection|
+            initialize_connection(connection).map(connection)
+          end
+        else
+          Future.failed(Io::ConnectionError.new('IO reactor stopped while connecting to %s:%d' % [host, port]))
+        end
+      end
+
+      def create_connection(raw_connection)
+        Ione::Rpc::ClientPeer.new(raw_connection, @codec, @max_channels)
+      end
+
+      def handle_connected(connection)
+        @logger.info('Connected to %s:%d' % [connection.host, connection.port]) if @logger
+        connection.on_closed { |error| handle_disconnected(connection, error) }
+        if connect?(connection.host, connection.port)
+          @lock.synchronize { @connections << connection }
+        else
+          connection.close
+        end
+      end
+
+      def connect?(host, port)
+        hosts = @lock.synchronize { @hosts.dup }
+        hosts.any? { |h, p, _| h == host && p == port }
+      end
+
+      def handle_disconnected(connection, error=nil)
+        message = 'Connection to %s:%d closed' % [connection.host, connection.port]
+        if error
+          @logger.warn(message << ' unexpectedly: ' << error.message) if @logger
+        else
+          @logger.info(message) if @logger
+        end
+        @lock.synchronize { @connections.delete(connection) }
+        connect(connection.host, connection.port) if error
+      end
+
+      def normalize_address(host, port)
+        if port.nil?
+          host, port = host.split(':')
+        end
+        port = port.to_i
+        return host, port
+      end
+    end
+  end
+end

data/lib/ione/rpc/client_peer.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+
+require 'ione'
+
+
+module Ione
+  module Rpc
+    # @private
+    class ClientPeer < Peer
+      def initialize(connection, codec, max_channels)
+        super(connection, codec)
+        @lock = Mutex.new
+        @channels = [nil] * max_channels
+        @queue = []
+      end
+
+      def send_message(request)
+        promise = Ione::Promise.new
+        channel = @lock.synchronize do
+          take_channel(promise)
+        end
+        if channel
+          write_message(request, channel)
+        else
+          @lock.synchronize do
+            @queue << [request, promise]
+          end
+        end
+        promise.future
+      end
+
+      private
+
+      def handle_message(response, channel)
+        promise = @lock.synchronize do
+          promise = @channels[channel]
+          @channels[channel] = nil
+          promise
+        end
+        if promise
+          promise.fulfill(response)
+        end
+        flush_queue
+      end
+
+      def flush_queue
+        @lock.synchronize do
+          count = 0
+          max = @queue.size
+          while count < max
+            request, promise = @queue[count]
+            if (channel = take_channel(promise))
+              write_message(request, channel)
+              count += 1
+            else
+              break
+            end
+          end
+          @queue = @queue.drop(count)
+        end
+      end
+
+      def take_channel(promise)
+        if (channel = @channels.index(nil))
+          @channels[channel] = promise
+          channel
+        end
+      end
+
+      def handle_closed(cause=nil)
+        error = Io::ConnectionClosedError.new('Connection closed')
+        promises_to_fail = @lock.synchronize { @channels.reject(&:nil?) }
+        promises_to_fail.each { |p| p.fail(error) }
+        super
+      end
+    end
+  end
+end