amq-client 0.5.0

data/lib/amq/client/settings.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+require "amq/protocol/client" # TODO: "amq/protocol/constants"
+
+module AMQ
+  module Client
+    # @see AMQ::Client::Settings.configure
+    module Settings
+      # Default connection settings used by AMQ clients
+      #
+      # @see AMQ::Client::Settings.configure
+      def self.default
+        {
+          # server
+          :host  => "127.0.0.1",
+          :port  => AMQ::Protocol::DEFAULT_PORT,
+
+          # login
+          :user  => "guest",
+          :pass  => "guest",
+          :vhost => "/",
+
+          # connection timeout
+          :timeout => nil,
+
+          # logging
+          :logging => false,
+
+          # ssl
+          :ssl => false,
+
+          # broker
+          # if you want to load broker-specific extensions
+          :broker => nil,
+
+          :frame_max => 131072
+        }
+      end
+
+      # Merges given configuration parameters with defaults and returns
+      # the result.
+      #
+      # @param [Hash] Configuration parameters to use.
+      #
+      # @option settings [String] :host ("127.0.0.1") Hostname AMQ broker runs on.
+      # @option settings [String] :port (5672) Port AMQ broker listens on.
+      # @option settings [String] :vhost ("/") Virtual host to use.
+      # @option settings [String] :user ("guest") Username to use for authentication.
+      # @option settings [String] :pass ("guest") Password to use for authentication.
+      # @option settings [String] :ssl (false) Should be use TLS (SSL) for connection?
+      # @option settings [String] :timeout (nil) Connection timeout.
+      # @option settings [String] :logging (false) Turns logging on or off.
+      # @option settings [String] :broker (nil) Broker name (use if you intend to use broker-specific features).
+      # @option settings [Fixnum] :frame_max (131072) Maximum frame size to use. If broker cannot support frames this large, broker's maximum value will be used instead.
+      #
+      # @return [Hash] Merged configuration parameters.
+      def self.configure(settings = nil)
+        case settings
+        when Hash then
+          if username = settings.delete(:username)
+            settings[:user] ||= username
+          end
+
+          if password = settings.delete(:password)
+            settings[:pass] ||= password
+          end
+
+
+          self.default.merge(settings)
+        when String then
+          settings = self.parse_amqp_url(settings)
+          self.default.merge(settings)
+        when NilClass then
+          self.default
+        end
+      end
+
+      def self.parse_amqp_url(string)
+        raise NotImplementedError.new
+      end
+    end
+  end
+end

data/lib/amq/client/version.rb

@@ -0,0 +1,5 @@
+module AMQ
+  module Client
+    VERSION = "0.5.0".freeze
+  end
+end

data/spec/benchmarks/adapters.rb

@@ -0,0 +1,77 @@
+Bundler.setup
+Bundler.require(:default)
+$LOAD_PATH.unshift(File.expand_path("../../../lib", __FILE__))
+
+require "amq/client/adapters/coolio"
+require "amq/client/adapters/event_machine"
+require "amq/client/queue"
+require "amq/client/exchange"
+
+TOTAL_MESSAGES = 10000
+# Short messages
+# Cool.io
+coolio_start = Time.now
+AMQ::Client::Coolio.connect(:port => 5672, :vhost => "/amq_client_testbed") do |client|
+  received_messages = 0
+  channel = AMQ::Client::Channel.new(client, 1)
+  channel.open { }
+  queue = AMQ::Client::Queue.new(client, channel)
+  queue.declare(false, false, false, true) { }
+
+  queue.bind("amq.fanout") { }
+
+  queue.consume(true) do |_, consumer_tag|
+
+    queue.on_delivery do |_, header, payload, consumer_tag, delivery_tag, redelivered, exchange, routing_key|
+      received_messages += 1
+      if received_messages == TOTAL_MESSAGES
+        client.disconnect do
+          Coolio::Loop.default.stop
+        end
+      end
+    end
+
+    exchange = AMQ::Client::Exchange.new(client, channel, "amq.fanout", :fanout)
+    TOTAL_MESSAGES.times do |i|
+      exchange.publish("Message ##{i}")
+    end
+  end
+end
+cool.io.run
+coolio_finish = Time.now
+
+# Eventmachine
+em_start = Time.now
+EM.run do
+  AMQ::Client::EventMachineClient.connect(:port => 5672, :vhost => "/amq_client_testbed") do |client|
+    received_messages = 0
+    channel = AMQ::Client::Channel.new(client, 1)
+    channel.open { }
+    queue = AMQ::Client::Queue.new(client, channel)
+    queue.declare(false, false, false, true) { }
+
+    queue.bind("amq.fanout") { }
+
+    queue.consume(true) do |_, consumer_tag|
+
+      queue.on_delivery do |_, header, payload, consumer_tag, delivery_tag, redelivered, exchange, routing_key|
+        received_messages += 1
+        if received_messages == TOTAL_MESSAGES
+          client.disconnect do
+            EM.stop
+          end
+        end
+      end
+
+      exchange = AMQ::Client::Exchange.new(client, channel, "amq.fanout", :fanout)
+      TOTAL_MESSAGES.times do |i|
+        exchange.publish("Message ##{i}")
+      end
+    end
+  end
+end
+em_finish = Time.now
+
+puts "Results for #{TOTAL_MESSAGES} messages:"
+puts "\tcool.io adapter: #{sprintf("%.3f", coolio_finish - coolio_start)}s"
+puts "\teventmachine adapter: #{sprintf("%.3f", em_finish - em_start)}s"

data/spec/client/framing/io_frame_spec.rb

@@ -0,0 +1,57 @@
+# encoding: binary
+
+require "spec_helper"
+require "stringio"
+
+# We need to require AMQ-Protocol manually.
+# In the library this is required in the file
+# amq/client.rb, but this is a unit test and
+# we don't want to mess around with unecessary
+# dependencies.
+require "amq/protocol/client"
+require "amq/protocol/frame"
+
+# We have to use Kernel#load so extensions to the
+# Logging module from client.rb will be overridden.
+load "amq/client/framing/io/frame.rb"
+
+describe AMQ::Client::Framing::IO do
+  subject do
+    AMQ::Client::Framing::IO::Frame
+  end
+
+  # Created by:
+  # frame = AMQ::Protocol::Queue::Declare.encode(1, "tasks", false, false, false, false, {})
+  # frame.encode
+  # frame.payload
+  before do
+    data = ["\x01\x00\x00\x00\x00\x00\b"]
+    data << "\x00\n\x00(\x01/\x00\x00"
+    data << "\xCE"
+    @io = StringIO.new(data.join)
+
+    subject.stub(:decode_header).with(data.first).and_return([1, 0, data[1].bytesize])
+  end
+
+  it "should be able to decode frame type" do
+    subject.decode(@io).should be_kind_of(AMQ::Protocol::MethodFrame)
+  end
+
+  it "should be able to decode channel" do
+    subject.decode(@io).channel.should eql(0)
+  end
+
+  it "should be able to decode payload" do
+    subject.decode(@io).payload.should eql("\x00\n\x00(\x01/\x00\x00")
+  end
+
+  it "should raise an error if the frame length is miscalculated" do
+    pending "How to do that with socket?"
+  end
+
+  it "should raise an error if the frame doesn't end with FINAL_OCTET" do
+    data = @io.read[0..-2] + "too long" + "\xCE"
+    io   = StringIO.new(data)
+    lambda { subject.decode(io) }.should raise_error(AMQ::Client::NoFinalOctetError)
+  end
+end

data/spec/client/framing/string_frame_spec.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+# We need to require AMQ-Protocol manually.
+# In the library this is required in the file
+# amq/client.rb, but this is a unit test and
+# we don't want to mess around with unecessary
+# dependencies.
+require "amq/protocol/client"
+require "amq/protocol/frame"
+
+# We have to use Kernel#load so extensions to the
+# Logging module from client.rb will be overridden.
+load "amq/client/framing/string/frame.rb"
+
+describe AMQ::Client::Framing::String do
+  subject do
+    AMQ::Client::Framing::String::Frame
+  end
+
+  # Created by:
+  # frame = AMQ::Protocol::Queue::Declare.encode(1, "tasks", false, false, false, false, {})
+  # frame.encode
+  # frame.payload
+  before do
+    data = ["\x01\x00\x00\x00\x00\x00\b"]
+    data << "\x00\n\x00(\x01/\x00\x00"
+    data << "\xCE"
+    @string = data.join
+
+    subject.stub(:decode_header).with(data.first).and_return([1, 0, data[1].bytesize])
+  end
+
+  it "should be able to decode frame type" do
+    subject.decode(@string).should be_kind_of(AMQ::Protocol::MethodFrame)
+  end
+
+  it "should be able to decode channel" do
+    subject.decode(@string).channel.should eql(0)
+  end
+
+  it "should be able to decode payload" do
+    subject.decode(@string).payload.should eql("\x00\n\x00(\x01/\x00\x00")
+  end
+
+  it "should raise an error if the frame length is miscalculated" do
+    data = @string[0..-2] + "too long" + "\xCE"
+    string   = String.new(data)
+    lambda { subject.decode(string) }.should raise_error(AMQ::Client::BadLengthError)
+  end
+
+  it "should raise an error if the frame doesn't end with FINAL_OCTET" do
+    string = @string[0..-2] + "x"
+    lambda { subject.decode(string) }.should raise_error(AMQ::Client::NoFinalOctetError)
+  end
+end

data/spec/client/protocol/get_response_spec.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+require "amq/protocol/client"
+require "amq/client/protocol/get_response"
+# require "amq/protocol/frame"
+#
+# # We have to use Kernel#load so extensions to the
+# # Logging module from client.rb will be overridden.
+# load "amq/client/framing/string/frame.rb"
+
+describe AMQ::Protocol::GetResponse do
+  describe "when method is GetOk" do
+    before  { @method = AMQ::Protocol::Basic::GetOk.new("dtag", true, "tasks", "foo", 1) }
+    subject { AMQ::Protocol::GetResponse.new(@method) }
+
+    it "should NOT be #empty?" do
+      should_not be_empty
+    end
+
+    it "should have #delivery_tag" do
+      subject.delivery_tag.should eql("dtag")
+    end
+
+    it "should have #redelivered" do
+      subject.redelivered.should be_true
+    end
+
+    it "should have #exchange" do
+      subject.exchange.should eql("tasks")
+    end
+
+    it "should have #routing_key" do
+      subject.routing_key.should eql("foo")
+    end
+
+    it "should have #message_count" do
+      subject.message_count.should eql(1)
+    end
+
+    it "should NOT have #cluster_id" do
+      subject.cluster_id.should be_nil
+    end
+  end
+
+  describe "when method is GetEmpty" do
+    before  { @method = AMQ::Protocol::Basic::GetEmpty.new("ID") }
+    subject { AMQ::Protocol::GetResponse.new(@method) }
+
+    it "should be #empty?" do
+      should be_empty
+    end
+
+    it "should NOT have #delivery_tag" do
+      subject.delivery_tag.should be_nil
+    end
+
+    it "should NOT have #redelivered" do
+      subject.redelivered.should be_nil
+    end
+
+    it "should NOT have #exchange" do
+      subject.exchange.should be_nil
+    end
+
+    it "should NOT have #routing_key" do
+      subject.routing_key.should be_nil
+    end
+
+    it "should NOT have #message_count" do
+      subject.message_count.should be_nil
+    end
+
+    it "should have #cluster_id" do
+      subject.cluster_id.should eql("ID")
+    end
+  end
+end

data/spec/integration/coolio/basic_ack_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'integration/coolio/spec_helper'
+
+require 'spec_helper'
+require 'integration/coolio/spec_helper'
+
+describe "AMQ::Client::Coolio", "Basic.Ack", :nojruby => true do
+  include EventedSpec::SpecHelper
+  default_timeout 1
+
+  context "sending 100 messages" do
+    let(:messages) { (0..99).map {|i| "Message #{i}" } }
+
+    it "should receive & acknowledge all the messages" do
+      @received_messages = []
+      coolio_amqp_connect do |client|
+        channel = AMQ::Client::Channel.new(client, 1)
+        channel.open do
+          queue = AMQ::Client::Queue.new(client, channel)
+          queue.declare.bind("amq.fanout")
+
+          queue.consume do |_, consumer_tag|
+            queue.on_delivery do |method, header, payload|
+              queue.acknowledge(method.delivery_tag)
+              @received_messages << payload
+            end
+
+            exchange = AMQ::Client::Exchange.new(client, channel, "amq.fanout", :fanout)
+            messages.each do |message|
+              exchange.publish(message)
+            end
+          end # consume
+        end # open
+
+        done(0.8) {
+          @received_messages.size.should == messages.size
+        }
+      end # coolio_amqp_connect
+    end # it
+  end # context
+end # describe

data/spec/integration/coolio/basic_get_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+require 'integration/coolio/spec_helper'
+
+describe "AMQ::Client::Coolio", "Basic.Get", :nojruby => true do
+  include EventedSpec::SpecHelper
+  default_timeout 1
+
+  context "when set two messages beforehand" do
+    let(:messages) { ["message 1", "message 2"] }
+
+    it "synchronously fetches all the messages" do
+      @received_messages = []
+      coolio_amqp_connect do |client|
+        channel = AMQ::Client::Channel.new(client, 1)
+
+        channel.open do
+          queue = AMQ::Client::Queue.new(client, channel)
+          queue.declare(false, false, false, true) do
+            queue.bind("amq.fanout")
+            exchange = AMQ::Client::Exchange.new(client, channel, "amq.fanout", :fanout)
+
+            messages.each do |message|
+              exchange.publish(message) do
+                puts "Published a message: #{message}"
+              end
+            end
+
+            queue.get(true) do |method, header, payload|
+              puts "Got #{payload}"
+              @received_messages << payload
+            end
+            queue.get(true) do |method, header, payload|
+              puts "Got #{payload}"
+              @received_messages << payload
+            end
+
+            done(0.5) {
+              @received_messages.should =~ messages
+
+              queue.purge
+            }
+          end
+        end
+      end
+    end
+  end
+
+
+  context "when sent no messages beforehand" do
+    it "should receive nils" do
+      coolio_amqp_connect do |client|
+        channel = AMQ::Client::Channel.new(client, 1)
+        channel.open do
+          queue = AMQ::Client::Queue.new(client, channel)
+          queue.declare(false, false, false, true)
+          queue.bind("amq.fanout")
+
+          exchange = AMQ::Client::Exchange.new(client, channel, "amq.fanout", :fanout)
+
+          queue.get(true) do |method, header, payload|
+            header.should be_nil
+            payload.should be_nil
+
+            done {
+              queue.purge
+            }
+          end # get
+        end
+      end # em_amqp_connect
+    end # it
+
+  end # context
+end