amqp-client 0.1.0 → 0.2.3

data/lib/amqp/client/channel.rb

@@ -6,17 +6,25 @@ module AMQP
   # AMQP Channel
   class Channel
     def initialize(connection, id)
-      @rpc = Queue.new
+      @replies = ::Queue.new
       @connection = connection
       @id = id
-      @closed = false
+      @consumers = {}
+      @confirm = nil
+      @last_confirmed = 0
+      @closed = nil
+      @on_return = nil
+      @open = false
     end
 
-    attr_reader :id
+    attr_reader :id, :consumers
 
     def open
+      return self if @open
+
       write_bytes FrameBytes.channel_open(@id)
       expect(:channel_open_ok)
+      @open = true
       self
     end
 
@@ -25,15 +33,44 @@ module AMQP
 
       write_bytes FrameBytes.channel_close(@id, reason, code)
       expect :channel_close_ok
-      @closed = true
+      @closed = [code, reason]
+    end
+
+    # Called when closed by server
+    def closed!(code, reason, classid, methodid)
+      write_bytes FrameBytes.channel_close_ok(@id)
+      @closed = [code, reason, classid, methodid]
+      @replies.close
+      @consumers.each { |_, q| q.close }
+      @consumers.clear
+    end
+
+    def exchange_declare(name, type, passive: false, durable: true, auto_delete: false, internal: false, **args)
+      write_bytes FrameBytes.exchange_declare(@id, name, type, passive, durable, auto_delete, internal, args)
+      expect :exchange_declare_ok
     end
 
-    def queue_declare(name = "", passive: false, durable: true, exclusive: false, auto_delete: false, **args)
+    def exchange_delete(name, if_unused: false, no_wait: false)
+      write_bytes FrameBytes.exchange_delete(@id, name, if_unused, no_wait)
+      expect :exchange_delete_ok
+    end
+
+    def exchange_bind(destination, source, binding_key, arguments = {})
+      write_bytes FrameBytes.exchange_bind(@id, destination, source, binding_key, false, arguments)
+      expect :exchange_bind_ok
+    end
+
+    def exchange_unbind(destination, source, binding_key, arguments = {})
+      write_bytes FrameBytes.exchange_unbind(@id, destination, source, binding_key, false, arguments)
+      expect :exchange_unbind_ok
+    end
+
+    def queue_declare(name = "", passive: false, durable: true, exclusive: false, auto_delete: false, arguments: {})
       durable = false if name.empty?
       exclusive = true if name.empty?
       auto_delete = true if name.empty?
 
-      write_bytes FrameBytes.queue_declare(@id, name, passive, durable, exclusive, auto_delete)
+      write_bytes FrameBytes.queue_declare(@id, name, passive, durable, exclusive, auto_delete, arguments)
       name, message_count, consumer_count = expect(:queue_declare_ok)
       {
         queue_name: name,
@@ -42,60 +79,230 @@ module AMQP
       }
     end
 
-    def basic_get(queue_name, no_ack: true)
-      return if @closed
+    def queue_delete(name, if_unused: false, if_empty: false, no_wait: false)
+      write_bytes FrameBytes.queue_delete(@id, name, if_unused, if_empty, no_wait)
+      message_count, = expect :queue_delete
+      message_count
+    end
+
+    def queue_bind(name, exchange, binding_key, arguments = {})
+      write_bytes FrameBytes.queue_bind(@id, name, exchange, binding_key, false, arguments)
+      expect :queue_bind_ok
+    end
+
+    def queue_purge(name, no_wait: false)
+      write_bytes FrameBytes.queue_purge(@id, name, no_wait)
+      expect :queue_purge_ok unless no_wait
+    end
+
+    def queue_unbind(name, exchange, binding_key, arguments = {})
+      write_bytes FrameBytes.queue_unbind(@id, name, exchange, binding_key, arguments)
+      expect :queue_unbind_ok
+    end
 
+    def basic_get(queue_name, no_ack: true)
       write_bytes FrameBytes.basic_get(@id, queue_name, no_ack)
-      resp = @rpc.shift
-      frame, = resp
+      frame, *rest = @replies.shift
       case frame
       when :basic_get_ok
-        _, exchange_name, routing_key, redelivered = resp
+        delivery_tag, exchange_name, routing_key, _message_count, redelivered = rest
         body_size, properties = expect(:header)
         pos = 0
-        body = ""
+        body = String.new("", capacity: body_size)
         while pos < body_size
-          body_part = expect(:body)
+          body_part, = expect(:body)
           body += body_part
           pos += body_part.bytesize
         end
-        Message.new(exchange_name, routing_key, properties, body, redelivered)
-      when :basic_get_empty
-        nil
-      else raise AMQP::Client::UnexpectedFrame, %i[basic_get_ok basic_get_empty], frame
+        Message.new(self, delivery_tag, exchange_name, routing_key, properties, body, redelivered)
+      when :basic_get_empty then nil
+      when nil              then raise AMQP::Client::ChannelClosedError.new(@id, *@closed)
+      else raise AMQP::Client::UnexpectedFrame.new(%i[basic_get_ok basic_get_empty], frame)
       end
     end
 
-    def basic_publish(exchange, routing_key, body, properties = {})
-      raise AMQP::Client::ChannelClosedError, @id if @closed
+    def basic_publish(body, exchange, routing_key, **properties)
+      frame_max = @connection.frame_max - 8
+      id = @id
 
-      write_bytes FrameBytes.basic_publish(@id, exchange, routing_key)
-      write_bytes FrameBytes.header(@id, body.bytesize, properties)
+      if 0 < body.bytesize && body.bytesize <= frame_max
+        write_bytes FrameBytes.basic_publish(id, exchange, routing_key, properties.delete(:mandatory) || false),
+                    FrameBytes.header(id, body.bytesize, properties),
+                    FrameBytes.body(id, body)
+        return @confirm ? @confirm += 1 : nil
+      end
 
-      # body frames, splitted on frame size
+      write_bytes FrameBytes.basic_publish(id, exchange, routing_key, properties.delete(:mandatory) || false),
+                  FrameBytes.header(id, body.bytesize, properties)
       pos = 0
-      while pos < body.bytesize
-        len = [4096, body.bytesize - pos].min
+      while pos < body.bytesize # split body into multiple frame_max frames
+        len = [frame_max, body.bytesize - pos].min
         body_part = body.byteslice(pos, len)
-        write_bytes FrameBytes.body(@id, body_part)
+        write_bytes FrameBytes.body(id, body_part)
         pos += len
       end
+      @confirm += 1 if @confirm
+    end
+
+    def basic_publish_confirm(body, exchange, routing_key, **properties)
+      confirm_select(no_wait: true)
+      id = basic_publish(body, exchange, routing_key, **properties)
+      wait_for_confirm(id)
+    end
+
+    # Consume from a queue
+    # worker_threads: 0 => blocking, messages are executed in the thread calling this method
+    def basic_consume(queue, tag: "", no_ack: true, exclusive: false, arguments: {},
+                      worker_threads: 1)
+      write_bytes FrameBytes.basic_consume(@id, queue, tag, no_ack, exclusive, arguments)
+      tag, = expect(:basic_consume_ok)
+      q = @consumers[tag] = ::Queue.new
+      msgs = ::Queue.new
+      Thread.new { recv_deliveries(tag, q, msgs) }
+      if worker_threads.zero?
+        while (msg = msgs.shift)
+          yield msg
+        end
+      else
+        threads = Array.new(worker_threads) do
+          Thread.new do
+            while (msg = msgs.shift)
+              yield(msg)
+            end
+          end
+        end
+        [tag, threads]
+      end
+    end
+
+    def basic_cancel(consumer_tag, no_wait: false)
+      consumer = @consumers.fetch(consumer_tag)
+      return if consumer.closed?
+
+      write_bytes FrameBytes.basic_cancel(@id, consumer_tag)
+      expect(:basic_cancel_ok) unless no_wait
+      consumer.close
+    end
+
+    def basic_qos(prefetch_count, prefetch_size: 0, global: false)
+      write_bytes FrameBytes.basic_qos(@id, prefetch_size, prefetch_count, global)
+      expect :basic_qos_ok
+    end
+
+    def basic_ack(delivery_tag, multiple: false)
+      write_bytes FrameBytes.basic_ack(@id, delivery_tag, multiple)
+    end
+
+    def basic_nack(delivery_tag, multiple: false, requeue: false)
+      write_bytes FrameBytes.basic_nack(@id, delivery_tag, multiple, requeue)
+    end
+
+    def basic_reject(delivery_tag, requeue: false)
+      write_bytes FrameBytes.basic_reject(@id, delivery_tag, requeue)
+    end
+
+    def basic_recover(requeue: false)
+      write_bytes FrameBytes.basic_recover(@id, requeue: requeue)
+      expect :basic_recover_ok
+    end
+
+    def confirm_select(no_wait: false)
+      return if @confirm
+
+      write_bytes FrameBytes.confirm_select(@id, no_wait)
+      expect :confirm_select_ok unless no_wait
+      @confirms = ::Queue.new
+      @confirm = 0
+    end
+
+    def wait_for_confirm(id)
+      raise ArgumentError, "Confirm id has to a positive number" unless id&.positive?
+      return true if @last_confirmed >= id
+
+      loop do
+        ack, delivery_tag, multiple = @confirms.shift || break
+        @last_confirmed = delivery_tag
+        return ack if delivery_tag == id || (delivery_tag > id && multiple)
+      end
+      false
+    end
+
+    def tx_select
+      write_bytes FrameBytes.tx_select(@id)
+      expect :tx_select_ok
+    end
+
+    def tx_commit
+      write_bytes FrameBytes.tx_commit(@id)
+      expect :tx_commit_ok
+    end
+
+    def tx_rollback
+      write_bytes FrameBytes.tx_rollback(@id)
+      expect :tx_rollback_ok
+    end
+
+    def reply(args)
+      @replies.push(args)
+    end
+
+    def confirm(args)
+      @confirms.push(args)
+    end
+
+    def message_returned(reply_code, reply_text, exchange, routing_key)
+      Thread.new do
+        body_size, properties = expect(:header)
+        body = String.new("", capacity: body_size)
+        while body.bytesize < body_size
+          body_part, = expect(:body)
+          body += body_part
+        end
+        msg = ReturnMessage.new(reply_code, reply_text, exchange, routing_key, properties, body)
+
+        if @on_return
+          @on_return.call(msg)
+        else
+          puts "[WARN] Message returned: #{msg.inspect}"
+        end
+      end
     end
 
-    def push(*args)
-      @rpc.push(*args)
+    def on_return(&block)
+      @on_return = block
     end
 
     private
 
-    def write_bytes(bytes)
-      @connection.write_bytes bytes
+    def recv_deliveries(consumer_tag, deliver_queue, msgs)
+      loop do
+        _, delivery_tag, redelivered, exchange, routing_key = deliver_queue.shift || raise(ClosedQueueError)
+        body_size, properties = expect(:header)
+        body = String.new("", capacity: body_size)
+        while body.bytesize < body_size
+          body_part, = expect(:body)
+          body += body_part
+        end
+        msgs.push Message.new(self, delivery_tag, exchange, routing_key, properties, body, redelivered, consumer_tag)
+      end
+    ensure
+      msgs.close
+    end
+
+    def write_bytes(*bytes)
+      raise AMQP::Client::ChannelClosedError.new(@id, *@closed) if @closed
+
+      @connection.write_bytes(*bytes)
     end
 
     def expect(expected_frame_type)
-      frame_type, args = @rpc.shift
-      frame_type == expected_frame_type || raise(UnexpectedFrame, expected_frame_type, frame_type)
-      args
+      loop do
+        frame_type, *args = @replies.shift
+        raise AMQP::Client::ChannelClosedError.new(@id, *@closed) if frame_type.nil?
+        return args if frame_type == expected_frame_type
+
+        @replies.push [frame_type, *args]
+      end
     end
   end
 end

data/lib/amqp/client/connection.rb

@@ -1,38 +1,96 @@
 # frozen_string_literal: true
 
+require "socket"
+require "uri"
+require "openssl"
+require_relative "./frames"
+require_relative "./channel"
+require_relative "./errors"
+
 module AMQP
-  # AMQP Connection
+  # Represents a single AMQP connection
   class Connection
-    def initialize(socket, channel_max, frame_max, heartbeat)
+    def self.connect(uri, **options)
+      read_loop_thread = options[:read_loop_thread] || true
+
+      uri = URI.parse(uri)
+      tls = uri.scheme == "amqps"
+      port = port_from_env || uri.port || (tls ? 5671 : 5672)
+      host = uri.host || "localhost"
+      user = uri.user || "guest"
+      password = uri.password || "guest"
+      vhost = URI.decode_www_form_component(uri.path[1..-1] || "/")
+      options = URI.decode_www_form(uri.query || "").map! { |k, v| [k.to_sym, v] }.to_h.merge(options)
+
+      socket = Socket.tcp host, port, connect_timeout: 20, resolv_timeout: 5
+      enable_tcp_keepalive(socket)
+      if tls
+        cert_store = OpenSSL::X509::Store.new
+        cert_store.set_default_paths
+        context = OpenSSL::SSL::SSLContext.new
+        context.cert_store = cert_store
+        context.verify_mode = OpenSSL::SSL::VERIFY_PEER unless [false, "false", "none"].include? options[:verify_peer]
+        socket = OpenSSL::SSL::SSLSocket.new(socket, context)
+        socket.sync_close = true # closing the TLS socket also closes the TCP socket
+        socket.hostname = host # SNI host
+        socket.connect
+      end
+      channel_max, frame_max, heartbeat = establish(socket, user, password, vhost, **options)
+      Connection.new(socket, channel_max, frame_max, heartbeat, read_loop_thread: read_loop_thread)
+    end
+
+    def initialize(socket, channel_max, frame_max, heartbeat, read_loop_thread: true)
       @socket = socket
       @channel_max = channel_max
       @frame_max = frame_max
       @heartbeat = heartbeat
       @channels = {}
       @closed = false
-      @rpc = Queue.new
-      Thread.new { read_loop }
+      @replies = Queue.new
+      Thread.new { read_loop } if read_loop_thread
     end
 
-    def channel
-      id = 1.upto(@channel_max) { |i| break i unless @channels.key? i }
-      ch = Channel.new(self, id)
-      @channels[id] = ch
+    attr_reader :frame_max
+
+    def channel(id = nil)
+      if id
+        ch = @channels[id] ||= Channel.new(self, id)
+      else
+        id = 1.upto(@channel_max) { |i| break i unless @channels.key? i }
+        ch = @channels[id] = Channel.new(self, id)
+      end
       ch.open
     end
 
+    # Declare a new channel, yield, and then close the channel
+    def with_channel
+      ch = channel
+      begin
+        yield ch
+      ensure
+        ch.close
+      end
+    end
+
     def close(reason = "", code = 200)
+      return if @closed
+
       write_bytes FrameBytes.connection_close(code, reason)
       expect(:close_ok)
       @closed = true
     end
 
-    def write_bytes(bytes)
-      @socket.write bytes
+    def closed?
+      @closed
     end
 
-    private
+    def write_bytes(*bytes)
+      @socket.write(*bytes)
+    rescue IOError, OpenSSL::OpenSSLError, SystemCallError => e
+      raise AMQP::Client::Error.new("Could not write to socket", cause: e)
+    end
 
+    # Reads from the socket, required for any kind of progress. Blocks until the connection is closed
     def read_loop
       socket = @socket
       frame_max = @frame_max
@@ -40,23 +98,31 @@ module AMQP
       loop do
         begin
           socket.readpartial(frame_max, buffer)
-        rescue IOError, EOFError
+        rescue IOError, OpenSSL::OpenSSLError, SystemCallError
           break
         end
 
-        buf_pos = 0
-        while buf_pos < buffer.bytesize
-          type, channel_id, frame_size = buffer.unpack("@#{buf_pos}C S> L>")
-          frame_end = buffer.unpack1("@#{buf_pos + 7 + frame_size} C")
-          raise AMQP::Client::UnexpectedFrameEnd if frame_end != 206
+        pos = 0
+        while pos < buffer.bytesize
+          buffer += socket.read(pos + 8 - buffer.bytesize) if pos + 8 > buffer.bytesize
+          type, channel_id, frame_size = buffer.byteslice(pos, 7).unpack("C S> L>")
+          if frame_size > frame_max
+            raise AMQP::Client::Error, "Frame size #{frame_size} larger than negotiated max frame size #{frame_max}"
+          end
+
+          frame_end_pos = pos + 7 + frame_size
+          buffer += socket.read(frame_end_pos - buffer.bytesize + 1) if frame_end_pos + 1 > buffer.bytesize
+          frame_end = buffer[frame_end_pos].ord
+          raise AMQP::Client::UnexpectedFrameEnd, frame_end if frame_end != 206
 
-          buf = buffer.byteslice(buf_pos, frame_size + 8)
-          buf_pos += frame_size + 8
+          buf = buffer.byteslice(pos, frame_size + 8)
+          pos += frame_size + 8
           parse_frame(type, channel_id, frame_size, buf) || return
         end
       end
     ensure
       @closed = true
+      @replies.close
       begin
         @socket.close
       rescue IOError
@@ -64,6 +130,8 @@ module AMQP
       end
     end
 
+    private
+
     def parse_frame(type, channel_id, frame_size, buf)
       case type
       when 1 # method frame
@@ -75,67 +143,255 @@ module AMQP
           case method_id
           when 50 # connection#close
             code, text_len = buf.unpack("@11 S> C")
-            text, error_class_id, error_method_id = buf.unpack("@14 a#{text_len} S> S>")
+            text = buf.byteslice(14, text_len).force_encoding("utf-8")
+            error_class_id, error_method_id = buf.byteslice(14 + text_len, 4).unpack("S> S>")
             warn "Connection closed #{code} #{text} #{error_class_id} #{error_method_id}"
             write_bytes FrameBytes.connection_close_ok
             return false
           when 51 # connection#close-ok
-            @rpc.push [:close_ok]
+            @replies.push [:close_ok]
             return false
           else raise AMQP::Client::UnsupportedMethodFrame, class_id, method_id
           end
         when 20 # channel
           case method_id
           when 11 # channel#open-ok
-            @channels[channel_id].push [:channel_open_ok]
+            @channels[channel_id].reply [:channel_open_ok]
           when 40 # channel#close
+            reply_code, reply_text_len = buf.unpack("@11 S> C")
+            reply_text = buf.byteslice(14, reply_text_len).force_encoding("utf-8")
+            classid, methodid = buf.byteslice(14 + reply_text_len, 4).unpack("S> S>")
             channel = @channels.delete(channel_id)
-            channel&.closed!
+            channel.closed!(reply_code, reply_text, classid, methodid)
           when 41 # channel#close-ok
-            @channels[channel_id].push [:channel_close_ok]
+            @channels[channel_id].reply [:channel_close_ok]
+          else raise AMQP::Client::UnsupportedMethodFrame, class_id, method_id
+          end
+        when 40 # exchange
+          case method_id
+          when 11 # declare-ok
+            @channels[channel_id].reply [:exchange_declare_ok]
+          when 21 # delete-ok
+            @channels[channel_id].reply [:exchange_delete_ok]
+          when 31 # bind-ok
+            @channels[channel_id].reply [:exchange_bind_ok]
+          when 51 # unbind-ok
+            @channels[channel_id].reply [:exchange_unbind_ok]
           else raise AMQP::Client::UnsupportedMethodFrame, class_id, method_id
           end
         when 50 # queue
           case method_id
-          when 11 # queue#declare-ok
+          when 11 # declare-ok
             queue_name_len = buf.unpack1("@11 C")
-            queue_name, message_count, consumer_count = buf.unpack("@12 a#{queue_name_len} L> L>")
-            @channels[channel_id].push [:queue_declare_ok, queue_name, message_count, consumer_count]
-          else raise AMQP::Client::UnsupportedMethodFrame, class_id, method_id
+            queue_name = buf.byteslice(12, queue_name_len).force_encoding("utf-8")
+            message_count, consumer_count = buf.byteslice(12 + queue_name_len, 8).unpack1("L> L>")
+            @channels[channel_id].reply [:queue_declare_ok, queue_name, message_count, consumer_count]
+          when 21 # bind-ok
+            @channels[channel_id].reply [:queue_bind_ok]
+          when 31 # purge-ok
+            @channels[channel_id].reply [:queue_purge_ok]
+          when 41 # delete-ok
+            message_count = buf.unpack1("@11 L>")
+            @channels[channel_id].reply [:queue_delete, message_count]
+          when 51 # unbind-ok
+            @channels[channel_id].reply [:queue_unbind_ok]
+          else raise AMQP::Client::UnsupportedMethodFrame.new class_id, method_id
           end
         when 60 # basic
           case method_id
+          when 11 # qos-ok
+            @channels[channel_id].reply [:basic_qos_ok]
+          when 21 # consume-ok
+            tag_len = buf.unpack1("@11 C")
+            tag = buf.byteslice(12, tag_len).force_encoding("utf-8")
+            @channels[channel_id].reply [:basic_consume_ok, tag]
+          when 30 # cancel
+            tag_len = buf.unpack1("@11 C")
+            tag = buf.byteslice(12, tag_len).force_encoding("utf-8")
+            no_wait = buf[12 + tag_len].ord
+            @channels[channel_id].consumers.fetch(tag).close
+            write_bytes FrameBytes.basic_cancel_ok(@id, tag) unless no_wait == 1
+          when 31 # cancel-ok
+            tag_len = buf.unpack1("@11 C")
+            tag = buf.byteslice(12, tag_len).force_encoding("utf-8")
+            @channels[channel_id].reply [:basic_cancel_ok, tag]
+          when 50 # return
+            reply_code, reply_text_len = buf.unpack("@11 S> C")
+            pos = 14
+            reply_text = buf.byteslice(pos, reply_text_len).force_encoding("utf-8")
+            pos += reply_text_len
+            exchange_len = buf[pos].ord
+            pos += 1
+            exchange = buf.byteslice(pos, exchange_len).force_encoding("utf-8")
+            pos += exchange_len
+            routing_key_len = buf[pos].ord
+            pos += 1
+            routing_key = buf.byteslice(pos, routing_key_len).force_encoding("utf-8")
+            @channels[channel_id].message_returned(reply_code, reply_text, exchange, routing_key)
+          when 60 # deliver
+            ctag_len = buf[11].ord
+            consumer_tag = buf.byteslice(12, ctag_len).force_encoding("utf-8")
+            pos = 12 + ctag_len
+            delivery_tag, redelivered, exchange_len = buf.byteslice(pos, 10).unpack("Q> C C")
+            pos += 8 + 1 + 1
+            exchange = buf.byteslice(pos, exchange_len).force_encoding("utf-8")
+            pos += exchange_len
+            rk_len = buf[pos].ord
+            pos += 1
+            routing_key = buf.byteslice(pos, rk_len).force_encoding("utf-8")
+            loop do
+              if (consumer = @channels[channel_id].consumers[consumer_tag])
+                consumer.push [:deliver, delivery_tag, redelivered == 1, exchange, routing_key]
+                break
+              else
+                Thread.pass
+              end
+            end
           when 71 # get-ok
-            delivery_tag, redelivered, exchange_name_len = buf.unpack("@11 Q> C C")
-            exchange_name = buf.byteslice(21, exchange_name_len)
-            pos = 21 + exchange_name_len
-            routing_key_len = buf.unpack1("@#{pos} C")
+            delivery_tag, redelivered, exchange_len = buf.unpack("@11 Q> C C")
+            pos = 21
+            exchange = buf.byteslice(pos, exchange_len).force_encoding("utf-8")
+            pos += exchange_len
+            routing_key_len = buf[pos].ord
             pos += 1
-            routing_key = buf.byteslice(pos, routing_key_len)
+            routing_key = buf.byteslice(pos, routing_key_len).force_encoding("utf-8")
             pos += routing_key_len
-            message_count = buf.unpack1("@#{pos} L>")
-            @channels[channel_id].push [:basic_get_ok, delivery_tag, exchange_name, routing_key, message_count, redelivered == 1]
+            message_count = buf.byteslice(pos, 4).unpack1("L>")
+            redelivered = redelivered == 1
+            @channels[channel_id].reply [:basic_get_ok, delivery_tag, exchange, routing_key, message_count, redelivered]
           when 72 # get-empty
-            @channels[channel_id].push [:basic_get_empty]
-          else raise AMQP::Client::UnsupportedMethodFrame, class_id, method_id
+            @channels[channel_id].reply [:basic_get_empty]
+          when 80 # ack
+            delivery_tag, multiple = buf.unpack("@11 Q> C")
+            @channels[channel_id].confirm [:ack, delivery_tag, multiple]
+          when 90 # reject
+            delivery_tag, requeue = buf.unpack("@11 Q> C")
+            @channels[channel_id].confirm [:reject, delivery_tag, requeue == 1]
+          when 111 # recover-ok
+            @channels[channel_id].reply [:basic_recover_ok]
+          when 120 # nack
+            delivery_tag, multiple, requeue = buf.unpack("@11 Q> C C")
+            @channels[channel_id].confirm [:nack, delivery_tag, multiple == 1, requeue == 1]
+          else raise AMQP::Client::UnsupportedMethodFrame.new class_id, method_id
+          end
+        when 85 # confirm
+          case method_id
+          when 11 # select-ok
+            @channels[channel_id].reply [:confirm_select_ok]
+          else raise AMQP::Client::UnsupportedMethodFrame.new class_id, method_id
+          end
+        when 90 # tx
+          case method_id
+          when 11 # select-ok
+            @channels[channel_id].reply [:tx_select_ok]
+          when 21 # commit-ok
+            @channels[channel_id].reply [:tx_commit_ok]
+          when 31 # rollback-ok
+            @channels[channel_id].reply [:tx_rollback_ok]
+          else raise AMQP::Client::UnsupportedMethodFrame.new class_id, method_id
           end
-        else raise AMQP::Client::UnsupportedMethodFrame, class_id, method_id
+        else raise AMQP::Client::UnsupportedMethodFrame.new class_id, method_id
         end
       when 2 # header
         body_size = buf.unpack1("@11 Q>")
-        @channels[channel_id].push [:header, body_size, nil]
+        properties = Properties.decode(buf.byteslice(19, buf.bytesize - 20))
+        @channels[channel_id].reply [:header, body_size, properties]
       when 3 # body
         body = buf.byteslice(7, frame_size)
-        @channels[channel_id].push [:body, body]
+        @channels[channel_id].reply [:body, body]
       else raise AMQP::Client::UnsupportedFrameType, type
       end
       true
     end
 
     def expect(expected_frame_type)
-      frame_type, args = @rpc.shift
-      frame_type == expected_frame_type || raise(UnexpectedFrame, expected_frame_type, frame_type)
+      frame_type, args = @replies.shift
+      frame_type == expected_frame_type || raise(UnexpectedFrame.new(expected_frame_type, frame_type))
       args
     end
+
+    def self.establish(socket, user, password, vhost, **options)
+      channel_max, frame_max, heartbeat = nil
+      socket.write "AMQP\x00\x00\x09\x01"
+      buf = String.new(capacity: 4096)
+      loop do
+        begin
+          socket.readpartial(4096, buf)
+        rescue IOError, OpenSSL::OpenSSLError, SystemCallError => e
+          raise AMQP::Client::Error, "Could not establish AMQP connection: #{e.message}"
+        end
+
+        type, channel_id, frame_size = buf.unpack("C S> L>")
+        frame_end = buf.unpack1("@#{frame_size + 7} C")
+        raise UnexpectedFrameEndError, frame_end if frame_end != 206
+
+        case type
+        when 1 # method frame
+          class_id, method_id = buf.unpack("@7 S> S>")
+          case class_id
+          when 10 # connection
+            raise AMQP::Client::Error, "Unexpected channel id #{channel_id} for Connection frame" if channel_id != 0
+
+            case method_id
+            when 10 # connection#start
+              properties = CLIENT_PROPERTIES.merge({ connection_name: options[:connection_name] })
+              socket.write FrameBytes.connection_start_ok "\u0000#{user}\u0000#{password}", properties
+            when 30 # connection#tune
+              channel_max, frame_max, heartbeat = buf.unpack("@11 S> L> S>")
+              channel_max = [channel_max, 2048].min
+              frame_max = [frame_max, 131_072].min
+              heartbeat = [heartbeat, 0].min
+              socket.write FrameBytes.connection_tune_ok(channel_max, frame_max, heartbeat)
+              socket.write FrameBytes.connection_open(vhost)
+            when 41 # connection#open-ok
+              return [channel_max, frame_max, heartbeat]
+            when 50 # connection#close
+              code, text_len = buf.unpack("@11 S> C")
+              text, error_class_id, error_method_id = buf.unpack("@14 a#{text_len} S> S>")
+              socket.write FrameBytes.connection_close_ok
+              raise AMQP::Client::Error, "Could not establish AMQP connection: #{code} #{text} #{error_class_id} #{error_method_id}"
+            else raise AMQP::Client::Error, "Unexpected class/method: #{class_id} #{method_id}"
+            end
+          else raise AMQP::Client::Error, "Unexpected class/method: #{class_id} #{method_id}"
+          end
+        else raise AMQP::Client::Error, "Unexpected frame type: #{type}"
+        end
+      end
+    rescue StandardError
+      socket.close rescue nil
+      raise
+    end
+
+    def self.enable_tcp_keepalive(socket)
+      socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
+      socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPIDLE, 60)
+      socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPINTVL, 10)
+      socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPCNT, 3)
+    rescue StandardError => e
+      warn "amqp-client: Could not enable TCP keepalive on socket. #{e.inspect}"
+    end
+
+    def self.port_from_env
+      return unless (port = ENV["AMQP_PORT"])
+
+      port.to_i
+    end
+
+    private_class_method :establish, :enable_tcp_keepalive, :port_from_env
+
+    CLIENT_PROPERTIES = {
+      capabilities: {
+        authentication_failure_close: true,
+        publisher_confirms: true,
+        consumer_cancel_notify: true,
+        exchange_exchange_bindings: true,
+        "basic.nack": true,
+        "connection.blocked": true
+      },
+      product: "amqp-client.rb",
+      platform: RUBY_DESCRIPTION,
+      version: AMQP::Client::VERSION,
+      information: "http://github.com/cloudamqp/amqp-client.rb"
+    }.freeze
   end
 end