amqp 0.7.0.pre → 0.7.0

data/lib/mq.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 #:main: README
 #
 
@@ -17,6 +19,18 @@ class MQ
 
   # Raised whenever an illegal operation is attempted.
   class Error < StandardError; end
+
+  class IncompatibleOptionsError < Error
+    def initialize(name, opts_1, opts_2)
+      super("There is already an instance called #{name} with options #{opts_1.inspect}, you can't define the same instance with different options (#{opts_2.inspect})!")
+    end
+  end
+
+  class ChannelClosedError < Error
+    def initialize(instance)
+      super("The channel #{instance.channel} was closed, you can't use it anymore!")
+    end
+  end
 end
 
 # The top-level class for building AMQP clients. This class contains several
@@ -116,9 +130,20 @@ end
 #  ["every 2 seconds", :received, Tue Jan 06 22:46:20 -0600 2009]
 #
 class MQ
+
+  #
+  # Behaviors
+  #
+
   include AMQP
   include EM::Deferrable
 
+
+
+  #
+  # API
+  #
+
   # Returns a new channel. A channel is a bidirectional virtual
   # connection between the client and the AMQP server. Elsewhere in the
   # library the channel is referred to in parameter lists as +mq+.
@@ -136,148 +161,28 @@ class MQ
   #    channel = MQ.new AMQP::connect
   #  end
   #
-  def initialize connection = nil
-    raise 'MQ can only be used from within EM.run{}' unless EM.reactor_running?
+  def initialize(connection = nil)
+    raise 'MQ can only be used from within EM.run {}' unless EM.reactor_running?
+
+    @_send_mutex = Mutex.new
+    @get_queue_mutex = Mutex.new
 
     @connection = connection || AMQP.start
 
-    conn.callback{ |c|
+    conn.callback { |c|
       @channel = c.add_channel(self)
       send Protocol::Channel::Open.new
     }
   end
-  attr_reader :channel, :connection
-
-  def check_content_completion
-    if @body.length >= @header.size
-      @header.properties.update(@method.arguments)
-      @consumer.receive @header, @body if @consumer
-      @body = @header = @consumer = @method = nil
-    end
-  end
-
-  # May raise a MQ::Error exception when the frame payload contains a
-  # Protocol::Channel::Close object.
-  #
-  # This usually occurs when a client attempts to perform an illegal
-  # operation. A short, and incomplete, list of potential illegal operations
-  # follows:
-  # * publish a message to a deleted exchange (NOT_FOUND)
-  # * declare an exchange using the reserved 'amq.' naming structure (ACCESS_REFUSED)
-  #
-  def process_frame frame
-    log :received, frame
-
-    case frame
-    when Frame::Header
-      @header = frame.payload
-      @body = ''
-      check_content_completion
-
-    when Frame::Body
-      @body << frame.payload
-      check_content_completion
-
-    when Frame::Method
-      case method = frame.payload
-      when Protocol::Channel::OpenOk
-        send Protocol::Access::Request.new(:realm => '/data',
-                                           :read => true,
-                                           :write => true,
-                                           :active => true,
-                                           :passive => true)
-
-      when Protocol::Access::RequestOk
-        @ticket = method.ticket
-        callback{
-          send Protocol::Channel::Close.new(:reply_code => 200,
-                                            :reply_text => 'bye',
-                                            :method_id => 0,
-                                            :class_id => 0)
-        } if @closing
-        succeed
-
-      when Protocol::Basic::CancelOk
-        if @consumer = consumers[ method.consumer_tag ]
-          @consumer.cancelled
-        else
-          MQ.error "Basic.CancelOk for invalid consumer tag: #{method.consumer_tag}"
-        end
 
-      when Protocol::Exchange::DeclareOk
-        # We can't use exchanges[method.exchange] because if the name would
-        # be an empty string, then AMQP broker generated a random one.
-        exchanges = self.exchanges.select { |exchange| exchange.opts[:nowait].eql?(false) }
-        exchange  = exchanges.reverse.find { |exchange| exchange.status.eql?(:unfinished) }
-        exchange.receive_response method
-
-      when Protocol::Queue::DeclareOk
-        # We can't use queues[method.queue] because if the name would
-        # be an empty string, then AMQP broker generated a random one.
-        queues = self.queues.select { |queue| queue.opts[:nowait].eql?(false) }
-        queue  = queues.reverse.find { |queue| queue.status.eql?(:unfinished) }
-        queue.receive_status method
-
-      when Protocol::Queue::BindOk
-        # We can't use queues[method.queue] because if the name would
-        # be an empty string, then AMQP broker generated a random one.
-        queues = self.queues.select { |queue| queue.opts[:nowait].eql?(false) }
-        queue  = queues.reverse.find { |queue| queue.status.eql?(:unbound) }
-        queue.after_bind method
-
-      when Protocol::Basic::Deliver, Protocol::Basic::GetOk
-        @method = method
-        @header = nil
-        @body = ''
-
-        if method.is_a? Protocol::Basic::GetOk
-          @consumer = get_queue{|q| q.shift }
-          MQ.error "No pending Basic.GetOk requests" unless @consumer
-        else
-          @consumer = consumers[ method.consumer_tag ]
-          MQ.error "Basic.Deliver for invalid consumer tag: #{method.consumer_tag}" unless @consumer
-        end
-
-      when Protocol::Basic::GetEmpty
-        if @consumer = get_queue{|q| q.shift }
-          @consumer.receive nil, nil
-        else
-          MQ.error "Basic.GetEmpty for invalid consumer"
-        end
-
-      when Protocol::Channel::Close
-        raise Error, "#{method.reply_text} in #{Protocol.classes[method.class_id].methods[method.method_id]} on #{@channel}"
-
-      when Protocol::Channel::CloseOk
-        @on_close && @on_close.call(self)
-
-        @closing = false
-        conn.callback{ |c|
-          c.channels.delete @channel
-          c.close if c.channels.empty?
-        }
+  attr_reader :channel, :connection, :status
+  alias :conn :connection
 
-      when Protocol::Basic::ConsumeOk
-        if @consumer = consumers[ method.consumer_tag ]
-          @consumer.confirm_subscribe
-        else
-          MQ.error "Basic.ConsumeOk for invalid consumer tag: #{method.consumer_tag}"
-        end
-      end
-    end
+  def closed?
+    @status.eql?(:closed)
   end
 
-  def send *args
-    conn.callback{ |c|
-      (@_send_mutex ||= Mutex.new).synchronize do
-        args.each do |data|
-          data.ticket = @ticket if @ticket and data.respond_to? :ticket=
-          log :sending, data
-          c.send data, :channel => @channel
-        end
-      end
-    }
-  end
+
 
   # Defines, intializes and returns an Exchange to act as an ingress
   # point for all published messages.
@@ -352,8 +257,16 @@ class MQ
   # * redeclare an already-declared exchange to a different type
   # * :passive => true and the exchange does not exist (NOT_FOUND)
   #
-  def direct name = 'amq.direct', opts = {}, &block
-    self.exchanges << Exchange.new(self, :direct, name, opts, &block)
+  def direct(name = 'amq.direct', opts = {}, &block)
+    if exchange = self.exchanges.find { |exchange| exchange.name == name }
+      extended_opts = Exchange.add_default_options(:direct, name, opts, block)
+
+      validate_parameters_match!(exchange, extended_opts)
+
+      exchange
+    else
+      self.exchanges << Exchange.new(self, :direct, name, opts, &block)
+    end
   end
 
   # Defines, intializes and returns an Exchange to act as an ingress
@@ -438,8 +351,16 @@ class MQ
   # * redeclare an already-declared exchange to a different type
   # * :passive => true and the exchange does not exist (NOT_FOUND)
   #
-  def fanout name = 'amq.fanout', opts = {}, &block
-    self.exchanges << Exchange.new(self, :fanout, name, opts, &block)
+  def fanout(name = 'amq.fanout', opts = {}, &block)
+    if exchange = self.exchanges.find { |exchange| exchange.name == name }
+      extended_opts = Exchange.add_default_options(:fanout, name, opts, block)
+
+      validate_parameters_match!(exchange, extended_opts)
+
+      exchange
+    else
+      self.exchanges << Exchange.new(self, :fanout, name, opts, &block)
+    end
   end
 
   # Defines, intializes and returns an Exchange to act as an ingress
@@ -550,8 +471,16 @@ class MQ
   # * redeclare an already-declared exchange to a different type
   # * :passive => true and the exchange does not exist (NOT_FOUND)
   #
-  def topic name = 'amq.topic', opts = {}, &block
-    self.exchanges << Exchange.new(self, :topic, name, opts, &block)
+  def topic(name = 'amq.topic', opts = {}, &block)
+    if exchange = self.exchanges.find { |exchange| exchange.name == name }
+      extended_opts = Exchange.add_default_options(:topic, name, opts, block)
+
+      validate_parameters_match!(exchange, extended_opts)
+
+      exchange
+    else
+      self.exchanges << Exchange.new(self, :topic, name, opts, &block)
+    end
   end
 
   # Defines, intializes and returns an Exchange to act as an ingress
@@ -630,8 +559,16 @@ class MQ
   # * redeclare an already-declared exchange to a different type
   # * :passive => true and the exchange does not exist (NOT_FOUND)
   # * using a value other than "any" or "all" for "x-match"
-  def headers name = 'amq.match', opts = {}, &block
-    self.exchanges << Exchange.new(self, :headers, name, opts, &block)
+  def headers(name = 'amq.match', opts = {}, &block)
+    if exchange = self.exchanges.find { |exchange| exchange.name == name }
+      extended_opts = Exchange.add_default_options(:headers, name, opts, block)
+
+      validate_parameters_match!(exchange, extended_opts)
+
+      exchange
+    else
+      self.exchanges << Exchange.new(self, :headers, name, opts, &block)
+    end
   end
 
   # Queues store and forward messages.  Queues can be configured in the server
@@ -647,8 +584,8 @@ class MQ
   #
   # == Options
   # * :passive => true | false (default false)
-  # If set, the server will not create the exchange if it does not
-  # already exist. The client can use this to check whether an exchange
+  # If set, the server will not create the queue if it does not
+  # already exist. The client can use this to check whether the queue
   # exists without modifying  the server state.
   #
   # * :durable => true | false (default false)
@@ -687,7 +624,7 @@ class MQ
   #
   # The server waits for a short period of time before
   # determining the queue is unused to give time to the client code
-  # to bind an exchange to it.
+  # to bind a queue to it.
   #
   # If the queue has been previously declared, this option is ignored
   # on subsequent declarations.
@@ -700,11 +637,19 @@ class MQ
   # not wait for a reply method.  If the server could not complete the
   # method it will raise a channel or connection exception.
   #
-  def queue name, opts = {}, &block
-    self.queues << Queue.new(self, name, opts, &block)
+  def queue(name, opts = {}, &block)
+    if queue = self.queues.find { |queue| queue.name == name }
+      extended_opts = Queue.add_default_options(name, opts, block)
+
+      validate_parameters_match!(queue, extended_opts)
+
+      queue
+    else
+      self.queues << Queue.new(self, name, opts, &block)
+    end
   end
 
-  def queue! name, opts = {}, &block
+  def queue!(name, opts = {}, &block)
     self.queues.add! Queue.new(self, name, opts, &block)
   end
 
@@ -744,7 +689,7 @@ class MQ
   #    end
   #  end
   #
-  def rpc name, obj = nil
+  def rpc(name, obj = nil)
     rpcs[name] ||= RPC.new(self, name, obj)
   end
 
@@ -772,7 +717,9 @@ class MQ
 
   def prefetch(size)
     @prefetch_size = size
+
     send Protocol::Basic::Qos.new(:prefetch_size => 0, :prefetch_count => size, :global => false)
+
     self
   end
 
@@ -784,7 +731,7 @@ class MQ
   # If this flag is true, the server will attempt to requeue the message, potentially then
   # delivering it to an alternative subscriber.
   #
-  def recover requeue = false
+  def recover(requeue = false)
     send Protocol::Basic::Recover.new(:requeue => requeue)
     self
   end
@@ -805,7 +752,7 @@ class MQ
 
   def get_queue
     if block_given?
-      (@get_queue_mutex ||= Mutex.new).synchronize{
+      @get_queue_mutex.synchronize {
         yield( @get_queue ||= [] )
       }
     end
@@ -833,26 +780,176 @@ class MQ
     @consumers = {}
 
     exs = @exchanges
-    @exchanges = {}
-    exs.each{ |_,e| e.reset } if exs
+    @exchanges = MQ::Collection.new
+    exs.each { |e| e.reset } if exs
 
     qus = @queues
-    @queues = {}
-    qus.each{ |_,q| q.reset } if qus
+    @queues = MQ::Collection.new
+    qus.each { |q| q.reset } if qus
 
     prefetch(@prefetch_size) if @prefetch_size
   end
 
+
+  #
+  # Implementation
+  #
+
+  # May raise a MQ::Error exception when the frame payload contains a
+  # Protocol::Channel::Close object.
+  #
+  # This usually occurs when a client attempts to perform an illegal
+  # operation. A short, and incomplete, list of potential illegal operations
+  # follows:
+  # * publish a message to a deleted exchange (NOT_FOUND)
+  # * declare an exchange using the reserved 'amq.' naming structure (ACCESS_REFUSED)
+  #
+  def process_frame(frame)
+    log :received, frame
+
+    case frame
+    when Frame::Header
+      @header = frame.payload
+      @body = ''
+      check_content_completion
+
+    when Frame::Body
+      @body << frame.payload
+      check_content_completion
+
+    when Frame::Method
+      case method = frame.payload
+      when Protocol::Channel::OpenOk
+        send Protocol::Access::Request.new(:realm => '/data',
+                                           :read => true,
+                                           :write => true,
+                                           :active => true,
+                                           :passive => true)
+
+      when Protocol::Access::RequestOk
+        @ticket = method.ticket
+        callback {
+          send Protocol::Channel::Close.new(:reply_code => 200,
+                                            :reply_text => 'bye',
+                                            :method_id => 0,
+                                            :class_id => 0)
+        } if @closing
+        succeed
+
+      when Protocol::Basic::CancelOk
+        if @consumer = consumers[ method.consumer_tag ]
+          @consumer.cancelled
+        else
+          MQ.error "Basic.CancelOk for invalid consumer tag: #{method.consumer_tag}"
+        end
+
+      when Protocol::Exchange::DeclareOk
+        # We can't use exchanges[method.exchange] because if the name would
+        # be an empty string, then AMQP broker generated a random one.
+        exchanges = self.exchanges.select { |exchange| exchange.opts[:nowait].eql?(false) }
+        exchange  = exchanges.reverse.find { |exchange| exchange.status.eql?(:unfinished) }
+        exchange.receive_response method
+
+      when Protocol::Queue::DeclareOk
+        # We can't use queues[method.queue] because if the name would
+        # be an empty string, then AMQP broker generated a random one.
+        queues = self.queues.select { |queue| queue.opts[:nowait].eql?(false) }
+        queue  = queues.reverse.find { |queue| queue.status.eql?(:unfinished) }
+        queue.receive_status method
+
+      when Protocol::Queue::BindOk
+        # We can't use queues[method.queue] because if the name would
+        # be an empty string, then AMQP broker generated a random one.
+        queues = self.queues.select { |queue| queue.sync_bind }
+        queue  = queues.reverse.find { |queue| queue.status.eql?(:unbound) }
+        queue.after_bind method
+
+      when Protocol::Basic::Deliver, Protocol::Basic::GetOk
+        @method = method
+        @header = nil
+        @body = ''
+
+        if method.is_a? Protocol::Basic::GetOk
+          @consumer = get_queue { |q| q.shift }
+          MQ.error "No pending Basic.GetOk requests" unless @consumer
+        else
+          @consumer = consumers[ method.consumer_tag ]
+          MQ.error "Basic.Deliver for invalid consumer tag: #{method.consumer_tag}" unless @consumer
+        end
+
+      when Protocol::Basic::GetEmpty
+        if @consumer = get_queue { |q| q.shift }
+          @consumer.receive nil, nil
+        else
+          MQ.error "Basic.GetEmpty for invalid consumer"
+        end
+
+      when Protocol::Channel::Close
+        @status = :closed
+        MQ.error "#{method.reply_text} in #{Protocol.classes[method.class_id].methods[method.method_id]} on #{@channel}"
+
+      when Protocol::Channel::CloseOk
+        @status = :closed
+        @on_close && @on_close.call(self)
+
+        @closing = false
+        conn.callback { |c|
+          c.channels.delete @channel
+          c.close if c.channels.empty?
+        }
+
+      when Protocol::Basic::ConsumeOk
+        if @consumer = consumers[ method.consumer_tag ]
+          @consumer.confirm_subscribe
+        else
+          MQ.error "Basic.ConsumeOk for invalid consumer tag: #{method.consumer_tag}"
+        end
+      end
+    end
+  end # process_frame
+
+
+  def send(*args)
+    conn.callback { |c|
+      @_send_mutex.synchronize do
+        args.each do |data|
+          unless self.closed?
+            data.ticket = @ticket if @ticket and data.respond_to? :ticket=
+            log :sending, data
+            c.send data, :channel => @channel
+          else
+            unless data.class == AMQP::Protocol::Channel::CloseOk
+              raise ChannelClosedError.new(self)
+            end
+          end
+        end
+      end
+    }
+  end # send
+
+
+  def check_content_completion
+    if @body.length >= @header.size
+      @header.properties.update(@method.arguments)
+      @consumer.receive @header, @body if @consumer
+      @body = @header = @consumer = @method = nil
+    end
+  end # check_content_completion
+
+
   private
 
-  def log *args
+  def log(*args)
     return unless MQ.logging
     pp args
     puts
-  end
+  end # log
 
-  attr_reader :connection
-  alias :conn :connection
+  def validate_parameters_match!(entity, parameters)
+    unless entity.opts == parameters || parameters[:passive]
+      raise IncompatibleOptionsError.new(entity.name, entity.opts, parameters)
+    end
+  end # validate_parameters_match!(entity, parameters)
 end
 
 #-- convenience wrapper (read: HACK) for thread-local MQ object