amqp 1.1.0.pre1 → 1.1.0.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 01406174e5cb3d674733040989c60c3c8c0392b3
-  data.tar.gz: c01d64774da2210e3c9d4b1ba8f3f934b7174209
+  metadata.gz: bf6a9a0cb453a3921f7de2457b275a75be95f468
+  data.tar.gz: d8dc60d937d51493248f5813734cef62472504fd
 SHA512:
-  metadata.gz: 268b7dd0dba139086ad620543cc034c402e794461e7908308e5a748c205020a9d815be0461dc0fa768dccca2c633bfd954220bd768f086ab3b252220a4eaa4b2
-  data.tar.gz: 304a194b0860926c7318d8f89b64de2a1e6fe6317249cde8d521581e5e9009b95ca93c6d86671a5aa3035802153974531cd4d5e903f167741a9dc4f937bbb6b0
+  metadata.gz: 3cb18aa1e1f532f2c82c32bc9ce6b0075fd43bf37952b2a8ada8f7f0bdfd043df13a5cf156b1c78d7b2d5cbbb6302987c6eeb9275af91d1ff1ba59a2a69b88bb
+  data.tar.gz: d18e7ff42f621a27ea2363adb1ac733fbc53bb6880cee7b0b7b0b88fcbbb8392aec9236499b61a9f4475a20172211a861184eb337843431e1f7ebfb02e932fb2

data/ChangeLog.md

@@ -1,5 +1,10 @@
 ## Changes Between 1.0.0 and 1.1.0
 
+### AMQ::Client is Removed
+
+`amq-client` has been incorporated into amqp gem. `AMQ::Client` and related
+modules are no longer available.
+
 ### AMQP::Channel#confirm_select is Now Delayed
 
 `AMQP::Channel#confirm_select` is now delayed until after the channel

data/Gemfile

@@ -15,8 +15,6 @@ def custom_gem(name, options = Hash.new)
 end
 
 custom_gem "eventmachine", ">= 1.0.0"
-# gem "json", :platform => :ruby_18
-custom_gem "amq-client",   :git => "git://github.com/ruby-amqp/amq-client.git",   :branch => "master"
 custom_gem "amq-protocol", :git => "git://github.com/ruby-amqp/amq-protocol.git", :branch => "master"
 
 group :development do

data/README.md

@@ -1,25 +1,39 @@
 # Ruby amqp gem: the asynchronous Ruby RabbitMQ client
 
-[Ruby amqp gem](http://rubyamqp.info) is a widely used, feature-rich, well-maintained asynchronous AMQP 0.9.1 client with batteries included.
-This library works with Ruby 1.8.7 (*except for p249*, see the FAQ), Ruby 1.9.2, Ruby 1.9.3, [JRuby](http://jruby.org), [Rubinius](http://rubini.us) as well as [REE](http://www.rubyenterpriseedition.com), and is licensed under the [Ruby License](http://www.ruby-lang.org/en/LICENSE.txt)
+[Ruby amqp gem](http://rubyamqp.info) is a widely used, feature-rich, well-maintained asynchronous RabbitMQ client with batteries included.
+This library works with
+
+ * Ruby 2.0
+ * Ruby 1.9.3
+ * [JRuby](http://jruby.org)
+ * [Rubinius](http://rubini.us)
+ * Ruby 1.9.2
+ * Ruby 1.8.7 (*except for p249*, see the FAQ)
+ * [REE](http://www.rubyenterpriseedition.com),
+
+and is licensed under the [Ruby License](http://www.ruby-lang.org/en/LICENSE.txt)
 
 0.8.0 and later versions of amqp gem implement [AMQP 0.9.1](http://www.rabbitmq.com/tutorials/amqp-concepts.html) (see also [AMQP 0.9.1 spec document](http://bit.ly/amqp091spec)) and support [RabbitMQ extensions to AMQP 0.9.1](http://www.rabbitmq.com/extensions.html).
 
 
-## I know what AMQP is, how do I get started?
+## I know what RabbitMQ is, how do I get started?
 
 See [Getting started with amqp gem](http://rubyamqp.info/articles/getting_started/) and other [amqp gem documentation guides](http://rubyamqp.info/).
 We recommend that you read [AMQP 0.9.1 Model Explained](http://www.rabbitmq.com/tutorials/amqp-concepts.html), too.
 
 
 
-## What is AMQP?
+## What is RabbitMQ?
 
-AMQP is an [open standard for messaging middleware](http://www.amqp.org/confluence/display/AMQP/About+AMQP) that
-emphasizes interoperability between different technologies (for example, Java, .NET, Ruby, Python, Node.js, Erlang, C and so on).
+RabbitMQ is an open source messaging middleware that emphasizes
+interoperability between different technologies (for example, Java,
+.NET, Ruby, Python, Node.js, Erlang, Go, C and so on).
 
-Key features of AMQP are very flexible yet simple routing and binary protocol efficiency. AMQP supports many sophisticated features, for example,
-message acknowledgements, returning of messages to producer, redelivery of messages that couldn't be processed, load balancing between message consumers and so on.
+Key features of RabbitMQ are very flexible yet simple routing and
+binary protocol efficiency. RabbitMQ supports many sophisticated
+features, for example, message acknowledgements, queue length limit,
+message TTL, redelivery of messages that couldn't be processed, load
+balancing between message consumers and so on.
 
 
 ## What is amqp gem good for?
@@ -83,25 +97,17 @@ On other OSes or [JRuby](http://jruby.org):
 #!/usr/bin/env ruby
 # encoding: utf-8
 
-require "rubygems"
-# or
-#
-# require "bundler"
-# Bundler.setup
-#
-# if you use Bundler
-
 require 'amqp'
 
 EventMachine.run do
   connection = AMQP.connect(:host => '127.0.0.1')
-  puts "Connecting to AMQP broker. Running #{AMQP::VERSION} version of the gem..."
+  puts "Connecting to RabbitMQ. Running #{AMQP::VERSION} version of the gem..."
 
-  channel  = AMQP::Channel.new(connection)
-  queue    = channel.queue("amqpgem.examples.hello_world", :auto_delete => true)
-  exchange = channel.default_exchange
+  ch  = AMQP::Channel.new(connection)
+  q   = ch.queue("amqpgem.examples.hello_world", :auto_delete => true)
+  x   = ch.default_exchange
 
-  queue.subscribe do |payload|
+  q.subscribe do |metadata, payload|
     puts "Received a message: #{payload}. Disconnecting..."
 
     connection.close {
@@ -109,14 +115,14 @@ EventMachine.run do
     }
   end
 
-  exchange.publish "Hello, world!", :routing_key => queue.name
+  x.publish "Hello, world!", :routing_key => q.name
 end
 ```
 
 
 [Getting started guide](http://rubyamqp.info/articles/getting_started/) explains this and two more examples in detail,
-and is written in a form of a tutorial. See [AMQP Model Explained](http://www.rabbitmq.com/tutorials/amqp-concepts.html) if you want
-to learn more about AMQP principles & concepts.
+and is written in a form of a tutorial. See [AMQP 0.9.1 Model Explained](http://www.rabbitmq.com/tutorials/amqp-concepts.html) if you want
+to learn more about RabbitMQ protocol principles & concepts.
 
 
 

data/amqp.gemspec

@@ -24,7 +24,6 @@ Gem::Specification.new do |s|
 
   # Dependencies
   s.add_dependency "eventmachine"
-  s.add_dependency "amq-client",   "~> 1.1.0.pre1"
   s.add_dependency "amq-protocol", ">= 1.6.0"
 
   s.rubyforge_project = "amqp"

data/lib/amq/protocol/get_response.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+# Purpose of this class is to simplify work with GetOk and GetEmpty.
+module AMQ
+  module Protocol
+    class GetResponse
+      attr_reader :method
+      def initialize(method)
+        @method = method
+      end
+
+      def empty?
+        @method.is_a?(::AMQ::Protocol::Basic::GetEmpty)
+      end
+
+      # GetOk attributes
+      def delivery_tag
+        if @method.respond_to?(:delivery_tag)
+          @method.delivery_tag
+        end
+      end
+
+      def redelivered
+        if @method.respond_to?(:redelivered)
+          @method.redelivered
+        end
+      end
+
+      def exchange
+        if @method.respond_to?(:exchange)
+          @method.exchange
+        end
+      end
+
+      def routing_key
+        if @method.respond_to?(:routing_key)
+          @method.routing_key
+        end
+      end
+
+      def message_count
+        if @method.respond_to?(:message_count)
+          @method.message_count
+        end
+      end
+
+      # GetEmpty attributes
+      def cluster_id
+        if @method.respond_to?(:cluster_id)
+          @method.cluster_id
+        end
+      end
+    end
+  end
+end

data/lib/amqp.rb

@@ -1,16 +1,250 @@
 # encoding: utf-8
 
 require "amq/protocol"
-require "amq/client"
-require "amq/client/adapters/event_machine"
 
 require "amqp/version"
 if RUBY_VERSION =~ /^1.8.7/
   require "amqp/compatibility/ruby187_patchlevel_check"
 end
+
+require "amqp/handlers_registry"
+require "amqp/callbacks"
+require "amqp/entity"
+
 require "amqp/exceptions"
-require "amqp/connection"
+require "amqp/settings"
+require "amqp/deferrable"
+require "amqp/session"
 require "amqp/exchange"
 require "amqp/queue"
 require "amqp/channel"
 require "amqp/header"
+
+# Top-level namespace of amqp gem. Please refer to "See also" section below.
+#
+# @see AMQP.connect
+# @see AMQP.start
+# @see AMQP::Channel
+# @see AMQP::Exchange
+# @see AMQP::Queue
+module AMQP
+
+  # Starts EventMachine event loop unless it is already running and connects
+  # to AMQP broker using {AMQP.connect}. It is generally a good idea to
+  # start EventMachine event loop in a separate thread and use {AMQP.connect}
+  # (for Web applications that do not use Thin or Goliath, it is the only option).
+  #
+  # See {AMQP.connect} for information about arguments this method takes and
+  # information about relevant topics such as authentication failure handling.
+  #
+  # @example Using AMQP.start to connect to AMQP broker, EventMachine loop isn't yet running
+  #  AMQP.start do |connection|
+  #    # default is to connect to localhost:5672, to root ("/") vhost as guest/guest
+  #
+  #    # this block never exits unless either AMQP.stop or EM.stop
+  #    # is called.
+  #
+  #    AMQP::Channel(connection) do |channel|
+  #      channel.queue("", :auto_delete => true).bind(channel.fanout("amq.fanout")).subscribe do |headers, payload|
+  #        # handle deliveries here
+  #      end
+  #    end
+  #  end
+  #
+  # @api public
+  def self.start(connection_options_or_string = {}, other_options = {}, &block)
+    EM.run do
+      if !@connection || @connection.closed? || @connection.closing?
+        @connection   = connect(connection_options_or_string, other_options, &block)
+      end
+      @channel      = Channel.new(@connection)
+      @connection
+    end
+  end
+
+  # Alias for {AMQP.start}
+  # @api public
+  def self.run(*args, &block)
+    self.start(*args, &block)
+  end
+
+  # Properly closes default AMQP connection and then underlying TCP connection.
+  # Pass it a block if you want a piece of code to be run once default connection
+  # is successfully closed.
+  #
+  # @note If default connection was never established or is in the closing state already,
+  #       this method has no effect.
+  # @api public
+  def self.stop(reply_code = 200, reply_text = "Goodbye", &block)
+    return if @connection.nil? || self.closing?
+
+    EM.next_tick do
+      if AMQP.channel and AMQP.channel.open? and AMQP.channel.connection.open?
+        AMQP.channel.close
+      end
+      AMQP.channel = nil
+
+
+      shim = Proc.new {
+        block.call
+
+        AMQP.connection = nil
+      }
+      @connection.disconnect(reply_code, reply_text, &shim)
+    end
+  end
+
+  # Indicates that default connection is closing.
+  #
+  # @return [Boolean]
+  # @api public
+  def self.closing?
+    @connection.closing?
+  end
+
+  # @return [Boolean] Current global logging value
+  # @api public
+  def self.logging
+    self.settings[:logging]
+  end
+
+  # @return [Boolean] Sets current global logging value
+  # @api public
+  def self.logging=(value)
+    self.settings[:logging] = !!value
+  end
+
+  # Default connection. When you do not pass connection instance to methods like
+  # {Channel#initialize}, AMQP gem will use this default connection.
+  #
+  # @api public
+  def self.connection
+    @connection
+  end
+
+  # "Default channel". A placeholder for apps that only want to use one channel. This channel is not global, *not* used
+  # under the hood by methods like {AMQP::Exchange#initialize} and only shared by exchanges/queues you decide on.
+  # To reiterate: this is only a conventience accessor, since many apps (especially Web apps) can get by with just one
+  # connection and one channel.
+  #
+  # @api public
+  def self.channel
+    @channel
+  end
+
+  # A placeholder for applications that only need one channel. If you use {AMQP.start} to set up default connection,
+  # {AMQP.channel} is open on that connection, but can be replaced by your application.
+  #
+  #
+  # @see AMQP.channel
+  # @api public
+  def self.channel=(value)
+    @channel = value
+  end
+
+  # Sets global connection object.
+  # @api public
+  def self.connection=(value)
+    @connection = value
+  end
+
+  # Alias for {AMQP.connection}
+  # @deprecated
+  # @api public
+  def self.conn
+    warn "AMQP.conn will be removed in 1.0. Please use AMQP.connection."
+    @connection
+  end
+
+  # Alias for {AMQP.connection=}
+  # @deprecated
+  # @api public
+  def self.conn=(value)
+    warn "AMQP.conn= will be removed in 1.0. Please use AMQP.connection=(connection)."
+    self.connection = value
+  end
+
+  # Connects to AMQP broker and yields connection object to the block as soon
+  # as connection is considered open.
+  #
+  #
+  # @example Using AMQP.connect with default connection settings
+  #
+  #   AMQP.connect do |connection|
+  #     AMQP::Channel.new(connection) do |channel|
+  #       # channel is ready: set up your messaging flow by creating exchanges,
+  #       # queues, binding them together and so on.
+  #     end
+  #   end
+  #
+  # @example Using AMQP.connect to connect to a public RabbitMQ instance with connection settings given as a hash
+  #
+  #   AMQP.connect(:host => "dev.rabbitmq.com", :username => "guest", :password => "guest") do |connection|
+  #     AMQP::Channel.new(connection) do |channel|
+  #       # ...
+  #     end
+  #   end
+  #
+  #
+  # @example Using AMQP.connect to connect to a public RabbitMQ instance with connection settings given as a URI
+  #
+  #   AMQP.connect "amqp://guest:guest@dev.rabbitmq.com:5672", :on_possible_authentication_failure => Proc.new { puts("Looks like authentication has failed") } do |connection|
+  #     AMQP::Channel.new(connection) do |channel|
+  #       # ...
+  #     end
+  #   end
+  #
+  #
+  # @overload connect(connection_string, options = {})
+  #   Used to pass connection parameters as a connection string
+  #   @param [String] :connection_string AMQP connection URI, à la JDBC connection string. For example: amqp://bus.megacorp.internal:5877/qa
+  #
+  #
+  # @overload connect(connection_options)
+  #   Used to pass connection options as a Hash.
+  #   @param [Hash] :connection_options AMQP connection options (:host, :port, :username, :vhost, :password)
+  #
+  # @option connection_options_or_string [String]  :host ("localhost") Host to connect to.
+  # @option connection_options_or_string [Integer] :port (5672) Port to connect to.
+  # @option connection_options_or_string [String]  :vhost ("/") Virtual host to connect to.
+  # @option connection_options_or_string [String]  :username ("guest") Username to use. Also can be specified as :user.
+  # @option connection_options_or_string [String]  :password ("guest") Password to use. Also can be specified as :pass.
+  # @option connection_options_or_string [Hash]  :ssl TLS (SSL) parameters to use.
+  # @option connection_options_or_string [Fixnum] :heartbeat (0) Connection heartbeat, in seconds. 0 means no heartbeat. Can also be configured server-side starting with RabbitMQ 3.0.
+  # @option connection_options_or_string [#call]  :on_tcp_connection_failure A callable object that will be run if connection to server fails
+  # @option connection_options_or_string [#call]  :on_possible_authentication_failure A callable object that will be run if authentication fails (see Authentication failure section)
+  #
+  #
+  # h2. Handling authentication failures
+  #
+  # AMQP 0.9.1 specification dictates that broker closes TCP connection when it detects that authentication
+  # has failed. However, broker does exactly the same thing when other connection-level exception occurs
+  # so there is no way to guarantee that connection was closed because of authentication failure.
+  #
+  # Because of that, AMQP gem follows Java client example and hints at _possibility_ of authentication failure.
+  # To handle it, pass a callable object (a proc, a lambda, an instance of a class that responds to #call)
+  # with :on_possible_authentication_failure option.
+  #
+  # @note This method assumes that EventMachine even loop is already running. If it is not the case or you are not sure, we recommend you use {AMQP.start} instead.
+  #       It takes exactly the same parameters.
+  # @return [AMQP::Session]
+  # @api public
+  def self.connect(connection_options_or_string = {}, other_options = {}, &block)
+    opts = case connection_options_or_string
+           when String then
+             AMQP::Settings.parse_connection_uri(connection_options_or_string)
+           when Hash then
+             connection_options_or_string
+           else
+             Hash.new
+           end
+
+    AMQP::Session.connect(opts.merge(other_options), &block)
+  end
+
+  # @return [Hash] Default AMQP connection settings. This hash may be modified.
+  # @api public
+  def self.settings
+    @settings ||= AMQP::Settings.default
+  end
+end # AMQP

data/lib/amqp/auth_mechanism_adapter.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+module AMQP
+  # Provides a flexible method for encoding AMQP credentials. PLAIN and
+  # EXTERNAL are provided by this gem. In order to implement a new
+  # authentication mechanism, create a subclass like so:
+  #
+  #   class MyAuthMechanism < AMQP::Async::AuthMechanismAdapter
+  #     auth_mechanism "X-MYAUTH"
+  #
+  #     def encode_credentials(username, password)
+  #       # ...
+  #     end
+  #   end
+  class AuthMechanismAdapter
+
+    # Find and instantiate an AuthMechanismAdapter.
+    #
+    # @param [Adapter] adapter The Adapter for which to encode credentials.
+    # @return [AuthMechanismAdapter] An AuthMechanismAdapter that can encode
+    #   credentials for the Adapter.
+    # @raise [NotImplementedError] The Adapter's mechanism does not
+    #   correspond to any known AuthMechanismAdapter.
+    def self.for_adapter(adapter)
+      registry[adapter.mechanism].new adapter
+    end
+
+    protected
+
+      # Used by subclasses to declare the mechanisms that an
+      # AuthMechanismAdapter understands.
+      #
+      # @param [Array<String>] mechanisms One or more mechanisms that can be
+      #   handled by the subclass.
+      def self.auth_mechanism(*mechanisms)
+        mechanisms.each {|mechanism| registry[mechanism] = self}
+      end
+
+    private
+
+      # Accesses the registry of AuthMechanismAdapter subclasses. Keys in
+      # this hash are the names of the authentication mechanisms; values are
+      # the classes that handle them. Referencing an unknown mechanism from
+      # this Hash will raise NotImplementedError.
+      def self.registry
+        @@registry ||= Hash.new {raise NotImplementedError}
+      end
+
+    public
+
+      # The Adapter that this AuthMechanismAdapter operates on behalf of.
+      attr_reader :adapter
+
+    private
+
+      # Create a new AuthMechanismAdapter. Users of this class should instead
+      # retrieve an instance through for_adapter.
+      def initialize(adapter)
+        @adapter = adapter
+      end
+  end
+end
+
+# pre-require builtin auth mechanisms
+Dir[File.join(File.dirname(__FILE__),
+              File.basename(__FILE__, '.rb'),
+              '*')].each do |f|
+  require f
+end