bunny 0.8.0 → 0.9.0.pre1

data/lib/bunny/socket.rb

@@ -0,0 +1,44 @@
+require "socket"
+
+module Bunny
+  # TCP socket extension that uses TCP_NODELAY and supports reading
+  # fully.
+  #
+  # Heavily inspired by Dalli::Server::KSocket from Dalli by Mike Perham.
+  class Socket < TCPSocket
+    attr_accessor :options
+
+    def self.open(host, port, options = {})
+      Timeout.timeout(options[:socket_timeout]) do
+        sock = new(host, port)
+        if Socket.constants.include?('TCP_NODELAY') || Socket.constants.include?(:TCP_NODELAY)
+          sock.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, true)
+        end
+        sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true) if options[:keepalive]
+        sock.options = {:host => host, :port => port}.merge(options)
+        sock
+      end
+    end
+
+    def read_fully(count, timeout = nil)
+      return nil if @eof
+
+      value = ''
+      begin
+        loop do
+          value << read_nonblock(count - value.bytesize)
+          break if value.bytesize >= count
+        end
+      rescue EOFError
+        @eof = true
+      rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+        if IO.select([self], nil, nil, options.fetch(:socket_timeout, timeout))
+          retry
+        else
+          raise Timeout::Error, "IO timeout when reading #{count} bytes"
+        end
+      end
+      value
+    end
+  end
+end

data/lib/bunny/system_timer.rb

@@ -1,14 +1,14 @@
-# encoding: utf-8
+# -*- encoding: utf-8; mode: ruby -*-
 
-module Bunny
-  # Used for ruby < 1.9.x
-  class SystemTimer < ::SystemTimer
+require "system_timer"
 
-    def timeout(seconds, exception)
-      timeout_after(seconds) do
+module Bunny
+  # Used for Ruby before 1.9
+  class SystemTimer
+    def self.timeout(seconds, exception)
+      ::SystemTimer.timeout_after(seconds) do
         yield
       end
     end
-
-  end
-end
+  end # SystemTimer
+end # Bunny

data/lib/bunny/transport.rb

@@ -0,0 +1,179 @@
+require "socket"
+require "thread"
+
+require "bunny/exceptions"
+require "bunny/socket"
+
+module Bunny
+  class Transport
+
+    #
+    # API
+    #
+
+    DEFAULT_CONNECTION_TIMEOUT = 5.0
+
+
+    attr_reader :host, :port, :socket, :connect_timeout
+
+    def initialize(host, port, opts)
+      @host = host
+      @port = port
+      @opts = opts
+
+      @ssl             = opts[:ssl] || false
+      @ssl_cert        = opts[:ssl_cert]
+      @ssl_key         = opts[:ssl_key]
+      @ssl_cert_string = opts[:ssl_cert_string]
+      @ssl_key_string  = opts[:ssl_key_string]
+      @verify_ssl      = opts[:verify_ssl].nil? || opts[:verify_ssl]
+
+      @read_write_timeout = opts[:socket_timeout] || 1
+      @read_write_timeout = nil if @read_write_timeout == 0
+      @disconnect_timeout = @read_write_timeout || @connect_timeout
+      @connect_timeout    = self.timeout_from(opts)
+
+      @frames             = Hash.new { Array.new }
+
+      initialize_socket
+    end
+
+
+    def uses_tls?
+      @ssl
+    end
+    alias tls? uses_tls?
+
+    def uses_ssl?
+      @ssl
+    end
+    alias ssl? uses_ssl?
+
+
+
+    # Writes data to the socket. If read/write timeout was specified, Bunny::ClientTimeout will be raised
+    # if the operation times out.
+    #
+    # @raise [ClientTimeout]
+    def write(*args)
+      begin
+        raise Bunny::ConnectionError.new('No connection - socket has not been created', @host, @port) if !@socket
+        if @read_write_timeout
+          Bunny::Timer.timeout(@read_write_timeout, Bunny::ClientTimeout) do
+            @socket.write(*args)
+          end
+        else
+          @socket.write(*args)
+        end
+      rescue Errno::EPIPE, Errno::EAGAIN, Bunny::ClientTimeout, IOError => e
+        close!
+        raise Bunny::ConnectionError, e.message
+      end
+    end
+    alias send_raw write
+
+    def close(reason = nil)
+      @socket.close if @socket and not @socket.closed?
+      @socket   = nil
+    end
+
+    def open?
+      !@socket.nil? && !@socket.closed?
+    end
+
+    def closed?
+      !open?
+    end
+
+    def flush
+      @socket.flush
+    end
+
+    def read_fully(*args)
+      @socket.read_fully(*args)
+    end
+
+    def read_ready?(timeout = nil)
+      io = IO.select([@socket].compact, nil, nil, timeout)
+      io && io[0].include?(@socket)
+    end
+
+
+    # Exposed primarily for Bunny::Channel
+    # @private
+    def read_next_frame(opts = {})
+      header    = @socket.read_fully(7)
+      type, channel, size = AMQ::Protocol::Frame.decode_header(header)
+      payload   = @socket.read_fully(size)
+      frame_end = @socket.read_fully(1)
+
+      # 1) the size is miscalculated
+      if payload.bytesize != size
+        raise BadLengthError.new(size, payload.bytesize)
+      end
+
+      # 2) the size is OK, but the string doesn't end with FINAL_OCTET
+      raise NoFinalOctetError.new if frame_end != AMQ::Protocol::Frame::FINAL_OCTET
+      AMQ::Protocol::Frame.new(type, payload, channel)
+    end
+
+
+    # Sends frame to the peer.
+    #
+    # @raise [ConnectionClosedError]
+    # @private
+    def send_frame(frame)
+      if closed?
+        raise ConnectionClosedError.new(frame)
+      else
+        send_raw(frame.encode)
+      end
+    end
+
+
+    protected
+
+    def initialize_socket
+      begin
+        @socket = Bunny::Timer.timeout(@connect_timeout, ConnectionTimeout) do
+          Bunny::Socket.open(@host, @port,
+                             :keepalive      => @opts[:keepalive],
+                             :socket_timeout => @connect_timeout)
+        end
+
+        if @ssl
+          require 'openssl' unless defined? OpenSSL::SSL
+          sslctx = OpenSSL::SSL::SSLContext.new
+          initialize_client_pair(sslctx)
+          @socket = OpenSSL::SSL::SSLSocket.new(@socket, sslctx)
+          @socket.sync_close = true
+          @socket.connect
+          @socket.post_connection_check(host) if @verify_ssl
+          @socket
+        end
+      rescue Exception => e
+        @status = :not_connected
+        raise Bunny::TCPConnectionFailed.new(e, self.hostname, self.port)
+      end
+
+      @socket
+    end
+
+    def initialize_client_pair(sslctx)
+      if @ssl_cert
+        @ssl_cert_string = File.read(@ssl_cert)
+      end
+      if @ssl_key
+        @ssl_key_string = File.read(@ssl_key)
+      end
+
+      sslctx.cert = OpenSSL::X509::Certificate.new(@ssl_cert_string) if @ssl_cert_string
+      sslctx.key = OpenSSL::PKey::RSA.new(@ssl_key_string) if @ssl_key_string
+      sslctx
+    end
+
+    def timeout_from(options)
+      options[:connect_timeout] || options[:connection_timeout] || options[:timeout] || DEFAULT_CONNECTION_TIMEOUT
+    end
+  end
+end

data/lib/bunny/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Bunny
-  VERSION = "0.8.0"
+  VERSION = "0.9.0.pre1"
 end

data/spec/compatibility/queue_declare_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe Bunny::Queue, "backwards compatibility API" do
+  let(:connection) do
+    c = Bunny.new
+    c.start
+    c
+  end
+
+  context "when queue name is specified" do
+    let(:name) { "a queue declared at #{Time.now.to_i}" }
+
+    it "declares a new queue with that name" do
+      q    = Bunny::Queue.new(connection, name)
+      q.name.should == name
+    end
+  end
+
+
+  context "when queue name is passed on as an empty string" do
+    it "uses server-assigned queue name" do
+      q = Bunny::Queue.new(connection, "")
+      q.name.should_not be_empty
+      q.name.should =~ /^amq.gen.+/
+      q.should be_server_named
+      q.delete
+    end
+  end
+
+
+  context "when queue name is completely omitted" do
+    it "uses server-assigned queue name" do
+      q = Bunny::Queue.new(connection)
+      q.name.should_not be_empty
+      q.name.should =~ /^amq.gen.+/
+      q.should be_server_named
+      q.delete
+    end
+  end
+end

data/spec/higher_level_api/integration/basic_ack_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+describe Bunny::Channel, "#ack" do
+  let(:connection) do
+    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+    c.start
+    c
+  end
+
+  after :all do
+    connection.close if connection.open?
+  end
+
+  subject do
+    connection.create_channel
+  end
+
+  context "with a valid (known) delivery tag" do
+    it "acknowleges a message" do
+      q = subject.queue("bunny.basic.ack.manual-acks", :exclusive => true)
+      x = subject.default_exchange
+
+      x.publish("bunneth", :routing_key => q.name)
+      sleep(0.25)
+      q.message_count.should == 1
+      delivery_details, properties, content = q.pop(:ack => true)
+
+      subject.ack(delivery_details.delivery_tag, true)
+      sleep(0.25)
+      q.message_count.should == 0
+
+      subject.close
+    end
+  end
+
+  context "with an invalid (random) delivery tag" do
+    it "causes a channel-level error" do
+      pending "We need to design async channel error handling for cases when there is no reply methods (e.g. basic.ack)"
+
+      q = subject.queue("bunny.basic.ack.unknown-delivery-tag", :exclusive => true)
+      x = subject.default_exchange
+
+      x.publish("bunneth", :routing_key => q.name)
+      sleep(0.25)
+      q.message_count.should == 1
+      _, _, content = q.pop(:ack => true)
+
+      subject.on_error do |ch, channel_close|
+        @channel_close = channel_close
+      end
+      # subject.ack(82, true)
+    end
+  end
+end

data/spec/higher_level_api/integration/basic_consume_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe Bunny::Queue, "#subscribe" do
+  let(:connection) do
+    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+    c.start
+    c
+  end
+
+  after :all do
+    connection.close if connection.open?
+  end
+
+  context "with automatic acknowledgement mode" do
+    let(:queue_name) { "bunny.basic_consume#{rand}" }
+
+    it "registers the consumer" do
+      delivered_keys = []
+      delivered_data = []
+
+      t = Thread.new do
+        ch = connection.create_channel
+        q = ch.queue(queue_name, :auto_delete => true, :durable => false)
+        q.subscribe(:exclusive => false, :ack => false) do |metadata, payload|
+          delivered_keys << metadata.routing_key
+          delivered_data << payload
+        end
+      end
+      t.abort_on_exception = true
+      sleep 0.5
+
+      ch = connection.create_channel
+      x  = ch.default_exchange
+      x.publish("hello", :routing_key => queue_name)
+
+      sleep 0.7
+      delivered_keys.should include(queue_name)
+      delivered_data.should include("hello")
+
+      ch.queue(queue_name, :auto_delete => true, :durable => false).message_count.should == 0
+
+      ch.close
+    end
+  end
+
+  context "with manual acknowledgement mode" do
+    let(:queue_name) { "bunny.basic_consume#{rand}" }
+
+    it "register a consumer with manual acknowledgements mode"
+  end
+end

data/spec/higher_level_api/integration/basic_get_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+
+describe Bunny::Queue, "#pop" do
+  let(:connection) do
+    c = Bunny.new(:user => "bunny_gem", :password => "bunny_password", :vhost => "bunny_testbed")
+    c.start
+    c
+  end
+
+  after :all do
+    connection.close if connection.open?
+  end
+
+  context "with all defaults" do
+    it "fetches a messages which is automatically acknowledged" do
+      ch = connection.create_channel
+
+      q  = ch.queue("", :exclusive => true)
+      x  = ch.default_exchange
+
+      x.publish("xyzzy", :routing_key => q.name)
+
+      sleep(0.5)
+      delivery_info, properties, content = q.pop
+      content.should == "xyzzy"
+      q.message_count.should == 0
+
+      ch.close
+    end
+  end
+
+
+  context "with an empty queue" do
+    it "returns an empty response" do
+      ch = connection.create_channel
+
+      q  = ch.queue("", :exclusive => true)
+      q.purge
+
+      _, _, content = q.pop
+      content.should be_nil
+      q.message_count.should == 0
+
+      ch.close
+    end
+  end
+end