amq-client 0.7.0.alpha25 → 0.7.0.alpha26

data/lib/amq/client/channel.rb

@@ -41,8 +41,8 @@ module AMQ
       attr_accessor :flow_is_active
 
 
-      def initialize(client, id)
-        super(client)
+      def initialize(connection, id)
+        super(connection)
 
         @id        = id
         @exchanges = Hash.new
@@ -54,8 +54,8 @@ module AMQ
         # 65536 is here for cases when channel is opened without passing a callback in,
         # otherwise channel_mix would be nil and it causes a lot of needless headaches.
         # lets just have this default. MK.
-        channel_max = if client.connection
-                        client.connection.channel_max || 65536
+        channel_max = if @connection.open?
+                        @connection.channel_max || 65536
                       else
                         65536
                       end
@@ -84,27 +84,27 @@ module AMQ
       #
       # @return [AMQ::Client::Connection] Connection this channel belongs to.
       def connection
-        @client.connection
+        @connection
       end # connection
 
       # Opens AMQP channel.
       #
       # @api public
       def open(&block)
-        @client.send Protocol::Channel::Open.encode(@id, AMQ::Protocol::EMPTY_STRING)
-        @client.connection.channels[@id] = self
+        @connection.send Protocol::Channel::Open.encode(@id, AMQ::Protocol::EMPTY_STRING)
+        @connection.channels[@id] = self
         self.status = :opening
 
-        self.define_callback :open, &block
+        self.redefine_callback :open, &block
       end
 
       # Closes AMQP channel.
       #
       # @api public
       def close(reply_code = 200, reply_text = DEFAULT_REPLY_TEXT, class_id = 0, method_id = 0, &block)
-        @client.send Protocol::Channel::Close.encode(@id, reply_code, reply_text, class_id, method_id)
+        @connection.send Protocol::Channel::Close.encode(@id, reply_code, reply_text, class_id, method_id)
 
-        self.define_callback :close, &block
+        self.redefine_callback :close, &block
       end
 
 
@@ -113,7 +113,7 @@ module AMQ
       # @api public
       # @see http://bit.ly/htCzCX AMQP 0.9.1 protocol documentation (Section 1.8.3.13.)
       def acknowledge(delivery_tag, multiple = false)
-        @client.send(Protocol::Basic::Ack.encode(self.id, delivery_tag, multiple))
+        @connection.send(Protocol::Basic::Ack.encode(self.id, delivery_tag, multiple))
 
         self
       end # acknowledge(delivery_tag, multiple = false)
@@ -123,7 +123,7 @@ module AMQ
       # @api public
       # @see http://bit.ly/htCzCX AMQP 0.9.1 protocol documentation (Section 1.8.3.14.)
       def reject(delivery_tag, requeue = true)
-        @client.send(Protocol::Basic::Reject.encode(self.id, delivery_tag, requeue))
+        @connection.send(Protocol::Basic::Reject.encode(self.id, delivery_tag, requeue))
 
         self
       end # reject(delivery_tag, requeue = true)
@@ -134,7 +134,7 @@ module AMQ
       # @note RabbitMQ as of 2.3.1 does not support prefetch_size.
       # @api public
       def qos(prefetch_size = 0, prefetch_count = 32, global = false, &block)
-        @client.send Protocol::Basic::Qos.encode(@id, prefetch_size, prefetch_count, global)
+        @connection.send Protocol::Basic::Qos.encode(@id, prefetch_size, prefetch_count, global)
 
         self.redefine_callback :qos, &block
         self
@@ -149,7 +149,7 @@ module AMQ
       # @see http://bit.ly/htCzCX AMQP 0.9.1 protocol documentation (Section 1.8.3.16.)
       # @api public
       def recover(requeue = true, &block)
-        @client.send(Protocol::Basic::Recover.encode(@id, requeue))
+        @connection.send(Protocol::Basic::Recover.encode(@id, requeue))
 
         self.redefine_callback :recover, &block
         self
@@ -166,7 +166,7 @@ module AMQ
       # @see http://bit.ly/htCzCX AMQP 0.9.1 protocol documentation (Section 1.5.2.3.)
       # @api public
       def flow(active = false, &block)
-        @client.send Protocol::Channel::Flow.encode(@id, active)
+        @connection.send Protocol::Channel::Flow.encode(@id, active)
 
         self.redefine_callback :flow, &block
         self
@@ -178,7 +178,7 @@ module AMQ
       #
       # @api public
       def tx_select(&block)
-        @client.send Protocol::Tx::Select.encode(@id)
+        @connection.send Protocol::Tx::Select.encode(@id)
 
         self.redefine_callback :tx_select, &block
         self
@@ -188,7 +188,7 @@ module AMQ
       #
       # @api public
       def tx_commit(&block)
-        @client.send Protocol::Tx::Commit.encode(@id)
+        @connection.send Protocol::Tx::Commit.encode(@id)
 
         self.redefine_callback :tx_commit, &block
         self
@@ -198,7 +198,7 @@ module AMQ
       #
       # @api public
       def tx_rollback(&block)
-        @client.send Protocol::Tx::Rollback.encode(@id)
+        @connection.send Protocol::Tx::Rollback.encode(@id)
 
         self.redefine_callback :tx_rollback, &block
         self
@@ -270,78 +270,77 @@ module AMQ
 
 
 
-      def handle_open_ok(method)
+      def handle_open_ok(open_ok)
         self.status = :opened
-        self.exec_callback_once_yielding_self(:open, method)
+        self.exec_callback_once_yielding_self(:open, open_ok)
       end
 
-      def handle_close_ok(method)
+      def handle_close_ok(close_ok)
         self.status = :closed
-        self.exec_callback_once_yielding_self(:close, method)
+        self.exec_callback_once_yielding_self(:close, close_ok)
       end
 
-      def handle_close(method)
+      def handle_close(channel_close)
         self.status = :closed
-        self.exec_callback_yielding_self(:error, method)
+        self.exec_callback_yielding_self(:error, channel_close)
 
-        self.handle_connection_interruption(method)
+        self.handle_connection_interruption(channel_close)
       end
 
-      # === Handlers ===
 
-      self.handle(Protocol::Channel::OpenOk) do |client, frame|
-        channel = client.connection.channels[frame.channel]
+
+      self.handle(Protocol::Channel::OpenOk) do |connection, frame|
+        channel = connection.channels[frame.channel]
         channel.handle_open_ok(frame.decode_payload)
       end
 
-      self.handle(Protocol::Channel::CloseOk) do |client, frame|
+      self.handle(Protocol::Channel::CloseOk) do |connection, frame|
         method   = frame.decode_payload
-        channels = client.connection.channels
+        channels = connection.channels
 
         channel  = channels[frame.channel]
         channels.delete(channel)
-
         channel.handle_close_ok(method)
       end
 
-      self.handle(Protocol::Channel::Close) do |client, frame|
+      self.handle(Protocol::Channel::Close) do |connection, frame|
         method   = frame.decode_payload
-        channels = client.connection.channels
+        channels = connection.channels
         channel  = channels[frame.channel]
 
         channel.handle_close(method)
       end
 
-      self.handle(Protocol::Basic::QosOk) do |client, frame|
-        channel = client.connection.channels[frame.channel]
+      self.handle(Protocol::Basic::QosOk) do |connection, frame|
+        channel = connection.channels[frame.channel]
         channel.exec_callback(:qos, frame.decode_payload)
       end
 
-      self.handle(Protocol::Basic::RecoverOk) do |client, frame|
-        channel = client.connection.channels[frame.channel]
+      self.handle(Protocol::Basic::RecoverOk) do |connection, frame|
+        channel = connection.channels[frame.channel]
         channel.exec_callback(:recover, frame.decode_payload)
       end
 
-      self.handle(Protocol::Channel::FlowOk) do |client, frame|
-        channel  = client.connection.channels[frame.channel]
+      self.handle(Protocol::Channel::FlowOk) do |connection, frame|
+        channel  = connection.channels[frame.channel]
         method   = frame.decode_payload
 
         channel.flow_is_active = method.active
         channel.exec_callback(:flow, method)
       end
 
-      self.handle(Protocol::Tx::SelectOk) do |client, frame|
-        channel = client.connection.channels[frame.channel]
+      self.handle(Protocol::Tx::SelectOk) do |connection, frame|
+        channel = connection.channels[frame.channel]
         channel.exec_callback(:tx_select, frame.decode_payload)
       end
 
-      self.handle(Protocol::Tx::CommitOk) do |client, frame|
-        channel = client.connection.channels[frame.channel]
+      self.handle(Protocol::Tx::CommitOk) do |connection, frame|
+        channel = connection.channels[frame.channel]
         channel.exec_callback(:tx_commit, frame.decode_payload)
       end
 
-      self.handle(Protocol::Tx::RollbackOk) do |client, frame|
-        channel = client.connection.channels[frame.channel]
+      self.handle(Protocol::Tx::RollbackOk) do |connection, frame|
+        channel = connection.channels[frame.channel]
         channel.exec_callback(:tx_rollback, frame.decode_payload)
       end
     end # Channel

data/lib/amq/client/entity.rb

@@ -53,11 +53,11 @@ module AMQ
       attr_reader :callbacks
 
 
-      def initialize(client)
-        @client    = client
+      def initialize(connection)
+        @connection = connection
         # Be careful with default values for #ruby hashes: h = Hash.new(Array.new); h[:key] ||= 1
         # won't assign anything to :key. MK.
-        @callbacks = Hash.new
+        @callbacks  = Hash.new
       end
 
 
@@ -65,7 +65,7 @@ module AMQ
         # Asynchronous error handling.
         # Set callback for given class (Queue for example)
         # or for the Connection class (or instance, of course).
-        callbacks = [self.callbacks[:close], self.client.connection.callbacks[:close]].flatten.compact
+        callbacks = [self.callbacks[:close], self.connection.callbacks[:close]].flatten.compact
 
         callbacks.map { |c| c.call(exception) } if callbacks.any?
       end

data/lib/amq/client/exchange.rb

@@ -34,12 +34,12 @@ module AMQ
       # @return [Symbol] One of :direct, :fanout, :topic, :headers
       attr_reader :type
 
-      def initialize(client, channel, name, type = :fanout)
+      def initialize(connection, channel, name, type = :fanout)
         if !(TYPES.include?(type.to_sym) || type.to_s =~ /^x-.+/i)
           raise IncompatibleExchangeTypeError.new(TYPES, type)
         end
 
-        @client  = client
+        @connection  = connection
         @channel = channel
         @name    = name
         @type    = type
@@ -49,7 +49,7 @@ module AMQ
           @channel.register_exchange(self)
         end
 
-        super(client)
+        super(connection)
       end
 
 
@@ -68,7 +68,7 @@ module AMQ
 
 
       def declare(passive = false, durable = false, auto_delete = false, nowait = false, arguments = nil, &block)
-        @client.send(Protocol::Exchange::Declare.encode(@channel.id, @name, @type.to_s, passive, durable, auto_delete, false, nowait, arguments))
+        @connection.send(Protocol::Exchange::Declare.encode(@channel.id, @name, @type.to_s, passive, durable, auto_delete, false, nowait, arguments))
 
         unless nowait
           self.define_callback(:declare, &block)
@@ -80,7 +80,7 @@ module AMQ
 
 
       def delete(if_unused = false, nowait = false, &block)
-        @client.send(Protocol::Exchange::Delete.encode(@channel.id, @name, if_unused, nowait))
+        @connection.send(Protocol::Exchange::Delete.encode(@channel.id, @name, if_unused, nowait))
 
         unless nowait
           self.define_callback(:delete, &block)
@@ -95,7 +95,7 @@ module AMQ
 
       def publish(payload, routing_key = AMQ::Protocol::EMPTY_STRING, user_headers = {}, mandatory = false, immediate = false, frame_size = nil, &block)
         headers = { :priority => 0, :delivery_mode => 2, :content_type => "application/octet-stream" }.merge(user_headers)
-        @client.send_frameset(Protocol::Basic::Publish.encode(@channel.id, payload, headers, @name, routing_key, mandatory, immediate, (frame_size || @client.connection.frame_max)))
+        @connection.send_frameset(Protocol::Basic::Publish.encode(@channel.id, payload, headers, @name, routing_key, mandatory, immediate, (frame_size || @connection.frame_max)))
 
         block.call if block
 
@@ -125,32 +125,24 @@ module AMQ
 
 
 
-      # === Handlers ===
-      # Get the first exchange which didn't receive Exchange.Declare-Ok yet and run its declare callback.
-      # The cache includes only exchanges with {nowait: false}.
-      self.handle(Protocol::Exchange::DeclareOk) do |client, frame|
-        method = frame.decode_payload
-
-        # We should have cache API, so it'll be easy to change caching behaviour easily.
-        # So in the amq-client we don't want to cache more than just the last instance per each channel,
-        # whereas more opinionated clients might want to have every single instance in the cache,
-        # so they can iterate over it etc.
-        channel = client.connection.channels[frame.channel]
+      self.handle(Protocol::Exchange::DeclareOk) do |connection, frame|
+        method   = frame.decode_payload
+        channel  = connection.channels[frame.channel]
         exchange = channel.exchanges_awaiting_declare_ok.shift
 
         exchange.handle_declare_ok(method)
       end # handle
 
 
-      self.handle(Protocol::Exchange::DeleteOk) do |client, frame|
-        channel  = client.connection.channels[frame.channel]
+      self.handle(Protocol::Exchange::DeleteOk) do |connection, frame|
+        channel  = connection.channels[frame.channel]
         exchange = channel.exchanges_awaiting_delete_ok.shift
         exchange.handle_delete_ok(frame.decode_payload)
       end # handle
 
 
-      self.handle(Protocol::Basic::Return) do |client, frame, content_frames|
-        channel  = client.connection.channels[frame.channel]
+      self.handle(Protocol::Basic::Return) do |connection, frame, content_frames|
+        channel  = connection.channels[frame.channel]
         method   = frame.decode_payload
         exchange = channel.find_exchange(method.exchange)
 

data/lib/amq/client/queue.rb

@@ -15,7 +15,7 @@ module AMQ
 
       include Entity
       include ServerNamedEntity
-      extend ProtocolMethodHandlers      
+      extend ProtocolMethodHandlers
 
 
       #
@@ -35,8 +35,8 @@ module AMQ
       # @param  [AMQ::Client::Channel]  AMQ channel this queue object uses.
       # @param  [String]                Queue name. Please note that AMQP spec does not require brokers to support Unicode for queue names.
       # @api public
-      def initialize(client, channel, name = AMQ::Protocol::EMPTY_STRING)
-        super(client)
+      def initialize(connection, channel, name = AMQ::Protocol::EMPTY_STRING)
+        super(connection)
 
         @name    = name
         @channel = channel
@@ -87,7 +87,7 @@ module AMQ
         @auto_delete = auto_delete
 
         nowait = true if !block && !@name.empty?
-        @client.send(Protocol::Queue::Declare.encode(@channel.id, @name, passive, durable, exclusive, auto_delete, nowait, arguments))
+        @connection.send(Protocol::Queue::Declare.encode(@channel.id, @name, passive, durable, exclusive, auto_delete, nowait, arguments))
 
         if !nowait
           self.append_callback(:declare, &block)
@@ -108,7 +108,7 @@ module AMQ
       # @see http://bit.ly/htCzCX AMQP 0.9.1 protocol documentation (Section 1.7.2.9.)
       def delete(if_unused = false, if_empty = false, nowait = false, &block)
         nowait = true unless block
-        @client.send(Protocol::Queue::Delete.encode(@channel.id, @name, if_unused, if_empty, nowait))
+        @connection.send(Protocol::Queue::Delete.encode(@channel.id, @name, if_unused, if_empty, nowait))
 
         if !nowait
           self.append_callback(:delete, &block)
@@ -134,7 +134,7 @@ module AMQ
                           exchange
                         end
 
-        @client.send(Protocol::Queue::Bind.encode(@channel.id, @name, exchange_name, routing_key, nowait, arguments))
+        @connection.send(Protocol::Queue::Bind.encode(@channel.id, @name, exchange_name, routing_key, nowait, arguments))
 
         if !nowait
           self.append_callback(:bind, &block)
@@ -159,7 +159,7 @@ module AMQ
                           exchange
                         end
 
-        @client.send(Protocol::Queue::Unbind.encode(@channel.id, @name, exchange_name, routing_key, arguments))
+        @connection.send(Protocol::Queue::Unbind.encode(@channel.id, @name, exchange_name, routing_key, arguments))
 
         self.append_callback(:unbind, &block)
         # TODO: handle channel & connection-level exceptions
@@ -179,7 +179,7 @@ module AMQ
 
         nowait        = true unless block
         @consumer_tag = generate_consumer_tag(name)
-        @client.send(Protocol::Basic::Consume.encode(@channel.id, @name, @consumer_tag, no_local, no_ack, exclusive, nowait, arguments))
+        @connection.send(Protocol::Basic::Consume.encode(@channel.id, @name, @consumer_tag, no_local, no_ack, exclusive, nowait, arguments))
 
         @channel.consumers[@consumer_tag] = self
 
@@ -220,7 +220,7 @@ module AMQ
       # @api public
       # @see http://bit.ly/htCzCX AMQP 0.9.1 protocol documentation (Section 1.8.3.10.)
       def get(no_ack = false, &block)
-        @client.send(Protocol::Basic::Get.encode(@channel.id, @name, no_ack))
+        @connection.send(Protocol::Basic::Get.encode(@channel.id, @name, no_ack))
 
         # most people only want one callback per #get call. Consider the following example:
         #
@@ -241,7 +241,7 @@ module AMQ
       def cancel(nowait = false, &block)
         raise "There is no consumer tag for this queue. This usually means that you are trying to unsubscribe a queue that never was subscribed for messages in the first place." if @consumer_tag.nil?
 
-        @client.send(Protocol::Basic::Cancel.encode(@channel.id, @consumer_tag, nowait))
+        @connection.send(Protocol::Basic::Cancel.encode(@channel.id, @consumer_tag, nowait))
         @consumer_tag = nil
         self.clear_callbacks(:delivery)
         self.clear_callbacks(:consume)
@@ -261,7 +261,7 @@ module AMQ
       # @see http://bit.ly/htCzCX AMQP 0.9.1 protocol documentation (Section 1.7.2.7.)
       def purge(nowait = false, &block)
         nowait = true unless block
-        @client.send(Protocol::Queue::Purge.encode(@channel.id, @name, nowait))
+        @connection.send(Protocol::Queue::Purge.encode(@channel.id, @name, nowait))
 
         if !nowait
           self.redefine_callback(:purge, &block)
@@ -358,49 +358,49 @@ module AMQ
 
       # Get the first queue which didn't receive Queue.Declare-Ok yet and run its declare callback.
       # The cache includes only queues with {nowait: false}.
-      self.handle(Protocol::Queue::DeclareOk) do |client, frame|
+      self.handle(Protocol::Queue::DeclareOk) do |connection, frame|
         method  = frame.decode_payload
 
-        channel = client.connection.channels[frame.channel]
+        channel = connection.channels[frame.channel]
         queue   = channel.queues_awaiting_declare_ok.shift
 
         queue.handle_declare_ok(method)
       end
 
 
-      self.handle(Protocol::Queue::DeleteOk) do |client, frame|
-        channel = client.connection.channels[frame.channel]
+      self.handle(Protocol::Queue::DeleteOk) do |connection, frame|
+        channel = connection.channels[frame.channel]
         queue   = channel.queues_awaiting_delete_ok.shift
         queue.handle_delete_ok(frame.decode_payload)
       end
 
 
-      self.handle(Protocol::Queue::BindOk) do |client, frame|
-        channel = client.connection.channels[frame.channel]
+      self.handle(Protocol::Queue::BindOk) do |connection, frame|
+        channel = connection.channels[frame.channel]
         queue   = channel.queues_awaiting_bind_ok.shift
 
         queue.handle_bind_ok(frame.decode_payload)
       end
 
 
-      self.handle(Protocol::Queue::UnbindOk) do |client, frame|
-        channel = client.connection.channels[frame.channel]
+      self.handle(Protocol::Queue::UnbindOk) do |connection, frame|
+        channel = connection.channels[frame.channel]
         queue   = channel.queues_awaiting_unbind_ok.shift
 
         queue.handle_unbind_ok(frame.decode_payload)
       end
 
 
-      self.handle(Protocol::Basic::ConsumeOk) do |client, frame|
-        channel = client.connection.channels[frame.channel]
+      self.handle(Protocol::Basic::ConsumeOk) do |connection, frame|
+        channel = connection.channels[frame.channel]
         queue   = channel.queues_awaiting_consume_ok.shift
 
         queue.handle_consume_ok(frame.decode_payload)
       end
 
 
-      self.handle(Protocol::Basic::CancelOk) do |client, frame|
-        channel = client.connection.channels[frame.channel]
+      self.handle(Protocol::Basic::CancelOk) do |connection, frame|
+        channel = connection.channels[frame.channel]
         queue   = channel.queues_awaiting_cancel_ok.shift
 
         queue.handle_consume_ok(frame.decode_payload)
@@ -408,8 +408,8 @@ module AMQ
 
 
       # Basic.Deliver
-      self.handle(Protocol::Basic::Deliver) do |client, method_frame, content_frames|
-        channel  = client.connection.channels[method_frame.channel]
+      self.handle(Protocol::Basic::Deliver) do |connection, method_frame, content_frames|
+        channel  = connection.channels[method_frame.channel]
         method   = method_frame.decode_payload
         queue    = channel.consumers[method.consumer_tag]
 
@@ -420,16 +420,16 @@ module AMQ
       end
 
 
-      self.handle(Protocol::Queue::PurgeOk) do |client, frame|
-        channel = client.connection.channels[frame.channel]
+      self.handle(Protocol::Queue::PurgeOk) do |connection, frame|
+        channel = connection.channels[frame.channel]
         queue   = channel.queues_awaiting_purge_ok.shift
 
         queue.handle_purge_ok(frame.decode_payload)
       end
 
 
-      self.handle(Protocol::Basic::GetOk) do |client, frame, content_frames|
-        channel = client.connection.channels[frame.channel]
+      self.handle(Protocol::Basic::GetOk) do |connection, frame, content_frames|
+        channel = connection.channels[frame.channel]
         queue   = channel.queues_awaiting_get_response.shift
         method  = frame.decode_payload
 
@@ -440,8 +440,8 @@ module AMQ
       end
 
 
-      self.handle(Protocol::Basic::GetEmpty) do |client, frame|
-        channel = client.connection.channels[frame.channel]
+      self.handle(Protocol::Basic::GetEmpty) do |connection, frame|
+        channel = connection.channels[frame.channel]
         queue   = channel.queues_awaiting_get_response.shift
 
         queue.handle_get_empty(frame.decode_payload)