sparqcode_bunny 0.0.1

data/lib/bunny/queue09.rb

@@ -0,0 +1,325 @@
+# encoding: utf-8
+
+module Bunny
+
+  # Queues store and forward messages. Queues can be configured in the server or created at runtime.
+  # Queues must be attached to at least one exchange in order to receive messages from publishers.
+  class Queue09 < Qrack::Queue
+    def initialize(client, name, opts = {})
+      # check connection to server
+      raise Bunny::ConnectionError, 'Not connected to server' if client.status == :not_connected
+
+      @client = client
+      @opts   = opts
+      @delivery_tag = nil
+
+      # Queues without a given name are named by the server and are generally
+      # bound to the process that created them.
+      if !name
+        opts = {
+          :passive => false,
+          :durable => false,
+          :exclusive => true,
+          :auto_delete => true,
+          :deprecated_ticket => 0
+        }.merge(opts)
+      end
+
+      # ignore the :nowait option if passed, otherwise program will hang waiting for a
+      # response that will not be sent by the server
+      opts.delete(:nowait)
+
+      opts = { :queue => name || '', :nowait => false, :deprecated_ticket => 0 }.merge(opts)
+
+      client.send_frame(Qrack::Protocol09::Queue::Declare.new(opts))
+
+      method = client.next_method
+
+      client.check_response(method, Qrack::Protocol09::Queue::DeclareOk, "Error declaring queue #{name}")
+
+      @name = method.queue
+      client.queues[@name] = self
+    end
+
+    # @return [Bunny::Consumer] Default consumer associated with this queue (if any), or nil
+    # @note Default consumer is the one registered with the convenience {Bunny::Queue#subscribe} method. It has no special properties of any kind.
+    # @see Queue#subscribe
+    # @see Bunny::Consumer
+    # @api public
+    def default_consumer
+      @default_consumer
+    end
+
+    # @return [Class]
+    # @private
+    def self.consumer_class
+      # Bunny::Consumer
+      Bunny::Subscription09
+    end # self.consumer_class
+
+    # Acknowledges one or more messages delivered via the _Deliver_ or _Get_-_Ok_ methods. The client can
+    # ask to confirm a single message or a set of messages up to and including a specific message.
+    #
+    # @option opts [String] :delivery_tag
+    #
+    # @option opts [Boolean] :multiple (false)
+    #   If set to @true@, the delivery tag is treated as "up to and including",
+    #   so that the client can acknowledge multiple messages with a single method.
+    #   If set to @false@, the delivery tag refers to a single message.
+    #   If the multiple field is @true@, and the delivery tag is zero,
+    #   tells the server to acknowledge all outstanding messages.
+    def ack(opts = {})
+      # Set delivery tag
+      if delivery_tag.nil? and opts[:delivery_tag].nil?
+        raise Bunny::AcknowledgementError, "No delivery tag received"
+      else
+        self.delivery_tag = opts[:delivery_tag] if delivery_tag.nil?
+      end
+
+      opts = {:delivery_tag => delivery_tag, :multiple => false}.merge(opts)
+
+      client.send_frame(Qrack::Protocol09::Basic::Ack.new(opts))
+
+      # reset delivery tag
+      self.delivery_tag = nil
+    end
+
+    # Binds a queue to an exchange. Until a queue is bound it won't receive
+    # any messages. Queues are bound to the direct exchange '' by default.
+    # If error occurs, a {Bunny::ProtocolError} is raised.
+    #
+    # @option opts [String] :key
+    #   Specifies the routing key for the binding. The routing key is used
+    #   for routing messages depending on the exchange configuration.
+    #
+    # @option opts [Boolean] :nowait (false)
+    #   Ignored by Bunny, always @false@.
+    #
+    # @return [Symbol] @:bind_ok@ if successful.
+    def bind(exchange, opts = {})
+      exchange = exchange.respond_to?(:name) ? exchange.name : exchange
+
+      # ignore the :nowait option if passed, otherwise program will hang waiting for a
+      # response that will not be sent by the server
+      opts.delete(:nowait)
+
+      opts = {
+        :queue => name,
+        :exchange => exchange,
+        :routing_key => opts.delete(:key),
+        :nowait => false,
+        :deprecated_ticket => 0
+      }.merge(opts)
+
+      client.send_frame(Qrack::Protocol09::Queue::Bind.new(opts))
+
+      method = client.next_method
+
+      client.check_response(method, Qrack::Protocol09::Queue::BindOk, "Error binding queue: #{name} to exchange: #{exchange}")
+
+      # return message
+      :bind_ok
+    end
+
+    # Requests that a queue is deleted from broker/server. When a queue is deleted any pending messages
+    # are sent to a dead-letter queue if this is defined in the server configuration. Removes reference
+    # from queues if successful. If an error occurs raises @Bunny::ProtocolError@.
+    #
+    # @option opts [Boolean] :if_unused (false)
+    #   If set to @true@, the server will only delete the queue if it has no consumers.
+    #   If the queue has consumers the server does not delete it but raises a channel exception instead.
+    #
+    # @option opts [Boolean] :if_empty (false)
+    #   If set to @true@, the server will only delete the queue if it has no messages.
+    #   If the queue is not empty the server raises a channel exception.
+    #
+    # @option opts [Boolean] :nowait (false)
+    #   Ignored by Bunny, always @false@.
+    #
+    # @return [Symbol] @:delete_ok@ if successful
+    def delete(opts = {})
+      # ignore the :nowait option if passed, otherwise program will hang waiting for a
+      # response that will not be sent by the server
+      opts.delete(:nowait)
+
+      opts = { :queue => name, :nowait => false, :deprecated_ticket => 0 }.merge(opts)
+
+      client.send_frame(Qrack::Protocol09::Queue::Delete.new(opts))
+
+      method = client.next_method
+
+      client.check_response(method, Qrack::Protocol09::Queue::DeleteOk, "Error deleting queue #{name}")
+
+      client.queues.delete(name)
+
+      # return confirmation
+      :delete_ok
+    end
+
+    # Gets a message from a queue in a synchronous way. If error occurs, raises _Bunny_::_ProtocolError_.
+    #
+    # @option opts [Boolean] :ack (false)
+    #   If set to @false@, the server does not expect an acknowledgement message
+    #   from the client. If set to @true@, the server expects an acknowledgement
+    #   message from the client and will re-queue the message if it does not receive
+    #   one within a time specified by the server.
+    #
+    # @return [Hash] Hash with @:header@, @:payload@ and @:delivery_details@ keys. @:delivery_details@ is a hash @:consumer_tag@, @:delivery_tag@, @:redelivered@, @:exchange@ and @:routing_key@. If the queue is empty the returned hash will contain: @{:header => nil, :payload => :queue_empty, :delivery_details => nil}@. N.B. If a block is provided then the hash will be passed into the block and the return value will be nil.
+    def pop(opts = {}, &blk)
+      opts = {
+        :queue => name,
+        :consumer_tag => name,
+        :no_ack => !opts[:ack],
+        :nowait => true,
+        :deprecated_ticket => 0
+      }.merge(opts)
+
+      client.send_frame(Qrack::Protocol09::Basic::Get.new(opts))
+
+      method = client.next_method
+
+      if method.is_a?(Qrack::Protocol09::Basic::GetEmpty) then
+        queue_empty = true
+      elsif !method.is_a?(Qrack::Protocol09::Basic::GetOk)
+        raise Bunny::ProtocolError, "Error getting message from queue #{name}"
+      end
+
+      if !queue_empty
+        # get delivery tag to use for acknowledge
+        self.delivery_tag = method.delivery_tag if opts[:ack]
+
+        header = client.next_payload
+
+        # If maximum frame size is smaller than message payload body then message
+        # will have a message header and several message bodies
+        msg = ''
+        while msg.length < header.size
+          msg << client.next_payload
+        end
+
+        msg_hash = {:header => header, :payload => msg, :delivery_details => method.arguments}
+
+      else
+        msg_hash = {:header => nil, :payload => :queue_empty, :delivery_details => nil}
+      end
+
+      # Pass message hash to block or return message hash
+      blk ? blk.call(msg_hash) : msg_hash
+    end
+
+    # Removes all messages from a queue.  It does not cancel consumers.  Purged messages are deleted
+    # without any formal "undo" mechanism. If an error occurs raises {Bunny::ProtocolError}.
+    #
+    # @option opts [Boolean] :nowait (false)
+    #   Ignored by Bunny, always @false@.
+    #
+    # @return [Symbol] @:purge_ok@ if successful
+    def purge(opts = {})
+      # ignore the :nowait option if passed, otherwise program will hang waiting for a
+      # response that will not be sent by the server
+      opts.delete(:nowait)
+
+      opts = { :queue => name, :nowait => false, :deprecated_ticket => 0 }.merge(opts)
+
+      client.send_frame(Qrack::Protocol09::Queue::Purge.new(opts))
+
+      method = client.next_method
+
+      client.check_response(method,   Qrack::Protocol09::Queue::PurgeOk, "Error purging queue #{name}")
+
+      # return confirmation
+      :purge_ok
+    end
+
+    # @return [Hash] Hash with keys @:message_count@ and @consumer_count@.
+    def status
+      opts = { :queue => name, :passive => true, :deprecated_ticket => 0 }
+      client.send_frame(Qrack::Protocol09::Queue::Declare.new(opts))
+
+      method = client.next_method
+      {:message_count => method.message_count, :consumer_count => method.consumer_count}
+    end
+
+    def subscribe(opts = {}, &blk)
+      raise RuntimeError.new("This queue already has default consumer. Please instantiate Bunny::Consumer directly and call its #consume method to register additional consumers.") if @default_consumer && ! opts[:consumer_tag]
+
+      # Create a subscription.
+      @default_consumer = self.class.consumer_class.new(client, self, opts)
+      @default_consumer.consume(&blk)
+    end
+
+    # Removes a queue binding from an exchange. If error occurs, a _Bunny_::_ProtocolError_ is raised.
+    #
+    # @option opts [String] :key
+    #   Specifies the routing key for the binding.
+    #
+    # @option opts [Boolean] :nowait (false)
+    #   Ignored by Bunny, always @false@.
+    #
+    # @return [Symbol] @:unbind_ok@ if successful.
+    def unbind(exchange, opts = {})
+      exchange = exchange.respond_to?(:name) ? exchange.name : exchange
+
+      # ignore the :nowait option if passed, otherwise program will hang waiting for a
+      # response that will not be sent by the server
+      opts.delete(:nowait)
+
+      opts = {
+        :queue => name,
+        :exchange => exchange,
+        :routing_key => opts.delete(:key),
+        :nowait => false,
+        :deprecated_ticket => 0
+      }.merge(opts)
+
+      client.send_frame(Qrack::Protocol09::Queue::Unbind.new(opts))
+
+      method = client.next_method
+
+      client.check_response(method, Qrack::Protocol09::Queue::UnbindOk, "Error unbinding queue #{name}")
+
+      # return message
+      :unbind_ok
+    end
+
+    # Cancels a consumer. This does not affect already delivered messages, but it does mean
+    # the server will not send any more messages for that consumer.
+    #
+    # @option opts [String] :consumer_tag
+    #   Specifies the identifier for the consumer.
+    #
+    # @option opts [Boolean] :nowait (false)
+    #   Ignored by Bunny, always @false@.
+    #
+    # @return [Symbol] @:unsubscribe_ok@ if successful
+    def unsubscribe(opts = {})
+      # Default consumer_tag from subscription if not passed in
+      consumer_tag = @default_consumer ? @default_consumer.consumer_tag : opts[:consumer_tag]
+
+      # Must have consumer tag to tell server what to unsubscribe
+      raise Bunny::UnsubscribeError,
+      "No consumer tag received" if !consumer_tag
+
+      # Cancel consumer
+      client.send_frame(Qrack::Protocol09::Basic::Cancel.new(:consumer_tag => consumer_tag, :nowait => false))
+
+      method = client.next_method
+
+      client.check_response(method, Qrack::Protocol09::Basic::CancelOk, "Error unsubscribing from queue #{name}")
+
+      # Reset subscription
+      @default_consumer = nil
+
+      # Return confirmation
+      :unsubscribe_ok
+    end
+
+    private
+
+    def exchange
+      @exchange ||= Bunny::Exchange09.new(client, '', :type => :direct, :key => name, :reserved_1 => 0, :reserved_2 => false, :reserved_3 => false)
+    end
+
+  end
+
+end

data/lib/bunny/subscription08.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+
+module Bunny
+
+=begin rdoc
+
+=== DESCRIPTION:
+
+Asks the server to start a "consumer", which is a transient request for messages from a specific
+queue. Consumers last as long as the channel they were created on, or until the client cancels them
+with an _unsubscribe_. Every time a message reaches the queue it is passed to the _blk_ for
+processing. If error occurs, _Bunny_::_ProtocolError_ is raised.
+
+==== OPTIONS:
+* <tt>:consumer_tag => '_tag_'</tt> - Specifies the identifier for the consumer. The consumer tag is
+  local to a connection, so two clients can use the same consumer tags. If this option is not
+  specified a server generated name is used.
+* <tt>:ack => false (_default_) or true</tt> - If set to _false_, the server does not expect an
+  acknowledgement message from the client. If set to _true_, the server expects an acknowledgement
+  message from the client and will re-queue the message if it does not receive one within a time specified
+  by the server.
+* <tt>:exclusive => true or false (_default_)</tt> - Request exclusive consumer access, meaning
+  only this consumer can access the queue.
+* <tt>:nowait => true or false (_default_)</tt> - Ignored by Bunny, always _false_.
+* <tt>:timeout => number of seconds - The subscribe loop will continue to wait for
+  messages until terminated (Ctrl-C or kill command) or this timeout interval is reached.
+* <tt>:message_max => max number messages to process</tt> - When the required number of messages
+  is processed subscribe loop is exited.
+
+==== OPERATION:
+
+Passes a hash of message information to the block, if one has been supplied. The hash contains
+:header, :payload and :delivery_details. The structure of the data is as follows -
+
+:header has instance variables -
+  @klass
+  @size
+  @weight
+  @properties is a hash containing -
+    :content_type
+    :delivery_mode
+    :priority
+
+:payload contains the message contents
+
+:delivery details is a hash containing -
+  :consumer_tag
+  :delivery_tag
+  :redelivered
+  :exchange
+  :routing_key
+
+If the :timeout option is specified then the subscription will
+automatically cease if the given number of seconds passes with no
+message arriving.
+
+==== EXAMPLES
+
+my_queue.subscribe(:timeout => 5) {|msg| puts msg[:payload]}
+
+my_queue.subscribe(:message_max => 10, :ack => true) {|msg| puts msg[:payload]}
+
+=end
+
+  class Subscription < Bunny::Consumer
+
+    def setup_consumer
+      subscription_options = {
+        :queue => queue.name,
+        :consumer_tag => consumer_tag,
+        :no_ack => !ack,
+        :exclusive => exclusive,
+        :nowait => false
+      }.merge(@opts)
+
+      client.send_frame(Qrack::Protocol::Basic::Consume.new(subscription_options))
+
+      method = client.next_method
+
+      client.check_response(method, Qrack::Protocol::Basic::ConsumeOk, "Error subscribing to queue #{queue.name}")
+
+      @consumer_tag = method.consumer_tag
+    end
+
+  end
+
+end

data/lib/bunny/subscription09.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+
+module Bunny
+
+  # Asks the server to start a "consumer", which is a transient request for messages from a specific
+  # queue. Consumers last as long as the channel they were created on, or until the client cancels them
+  # with an @unsubscribe@. Every time a message reaches the queue it is passed to the @blk@ for
+  # processing. If error occurs, {Bunny::ProtocolError} is raised.
+  #
+  # @option opts [String] :consumer_tag
+  #   Specifies the identifier for the consumer. The consumer tag is
+  #   local to a connection, so two clients can use the same consumer tags.
+  #   If this option is not specified a server generated name is used.
+  #
+  # @option opts [Boolean] :ack (false)
+  #   If set to @false@, the server does not expect an acknowledgement message
+  #   from the client. If set to @true, the server expects an acknowledgement
+  #   message from the client and will re-queue the message if it does not
+  #   receive one within a time specified by the server.
+  #
+  # @option opts [Boolean] :exclusive (false)
+  #   Request exclusive consumer access, meaning only this consumer can access the queue.
+  #
+  # @option opts [Boolean] :nowait (false)
+  #   Ignored by Bunny, always @false@.
+  #
+  # @option opts [Numeric] :timeout
+  #   The subscribe loop will continue to wait for messages
+  #   until terminated (Ctrl-C or kill command) or this timeout interval is reached.
+  #
+  # @option opts [Integer] :message_max
+  #   When the required number of messages is processed subscribe loop is exited.
+  #
+  # h2. Operation
+  #
+  # Passes a hash of message information to the block, if one has been supplied. The hash contains
+  # :header, :payload and :delivery_details. The structure of the data is as follows -
+  #
+  # :header has instance variables -
+  #   @klass
+  #   @size
+  #   @weight
+  #   @properties is a hash containing -
+  #     :content_type
+  #     :delivery_mode
+  #     :priority
+  #
+  # :payload contains the message contents
+  #
+  # :delivery details is a hash containing -
+  #   :consumer_tag
+  #   :delivery_tag
+  #   :redelivered
+  #   :exchange
+  #   :routing_key
+  #
+  # If the :timeout option is specified then the subscription will
+  # automatically cease if the given number of seconds passes with no
+  # message arriving.
+  #
+  # @example
+  #   my_queue.subscribe(timeout: 5) { |msg| puts msg[:payload] }
+  #   my_queue.subscribe(message_max: 10, ack: true) { |msg| puts msg[:payload] }
+  class Subscription09 < Bunny::Consumer
+
+    def setup_consumer
+      subscription_options = {
+        :deprecated_ticket => 0,
+        :queue => queue.name,
+        :consumer_tag => consumer_tag,
+        :no_ack => !ack,
+        :exclusive => exclusive,
+        :nowait => false
+      }.merge(@opts)
+
+      client.send_frame(Qrack::Protocol09::Basic::Consume.new(subscription_options))
+
+      method = client.next_method
+
+      client.check_response(method, Qrack::Protocol09::Basic::ConsumeOk, "Error subscribing to queue #{queue.name}")
+
+      @consumer_tag = method.consumer_tag
+    end
+
+  end
+
+end

data/lib/bunny/system_timer.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module Bunny
+  # Used for ruby < 1.9.x
+  class SystemTimer < ::SystemTimer
+
+    def timeout(seconds, exception)
+      timeout_after(seconds) do
+        yield
+      end
+    end
+
+  end
+end

data/lib/bunny/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module Bunny
+  VERSION = "0.0.1"
+end

data/lib/bunny.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+
+require "socket"
+require "thread"
+require "timeout"
+require "logger"
+
+require File.expand_path("../bunny/version", __FILE__)
+# if we don't require the version file the same way as in the gemspec,
+# the version file will be loaded twice. and we hate warnings.
+
+module Bunny
+
+  class ConnectionError < StandardError; end
+  class ForcedChannelCloseError < StandardError; end
+  class ForcedConnectionCloseError < StandardError; end
+  class MessageError < StandardError; end
+  class ProtocolError < StandardError; end
+  class ServerDownError < StandardError; end
+  class UnsubscribeError < StandardError; end
+  class AcknowledgementError < StandardError; end
+
+  # Returns the Bunny version number
+
+  def self.version
+    VERSION
+  end
+
+  # Print deprecation warning.
+  def self.deprecation_warning(method, version, explanation)
+    warn "~ #{method} will be removed in Bunny #{version}. #{explanation}"
+  end
+
+  # Instantiates new Bunny::Client
+
+  def self.new(connection_string_or_opts = Hash.new, opts = Hash.new)
+    # Set up Bunny according to AMQP spec version required
+    if connection_string_or_opts.respond_to?(:keys) && opts.empty?
+      opts = connection_string_or_opts
+    end
+
+    spec_version = opts[:spec] || '08'
+
+    # Return client
+    setup(spec_version, connection_string_or_opts, opts)
+  end
+
+  # Runs a code block using a short-lived connection
+
+  def self.run(opts = {}, &block)
+    raise ArgumentError, 'Bunny#run requires a block' unless block
+
+    # Set up Bunny according to AMQP spec version required
+    spec_version = opts[:spec] || '08'
+    client = setup(spec_version, opts)
+
+    begin
+      client.start
+      block.call(client)
+    ensure
+      client.stop
+    end
+
+    # Return success
+    :run_ok
+  end
+
+  Timer = if RUBY_VERSION < "1.9"
+            begin
+              require File.expand_path(File.join(File.dirname(__FILE__), 'system_timer.rb'))
+              Bunny::SystemTimer
+            rescue LoadError
+              Timeout
+            end
+          else
+            Timeout
+          end
+
+  private
+
+  def self.setup(version, *args)
+    if version == '08'
+      # AMQP 0-8 specification
+      require 'qrack/qrack08'
+      require 'bunny/client08'
+      require 'bunny/exchange08'
+      require 'bunny/queue08'
+      require 'bunny/channel08'
+      require 'bunny/subscription08'
+
+      client = Bunny::Client.new(*args)
+    else
+      # AMQP 0-9-1 specification
+      require 'qrack/qrack09'
+      require 'bunny/client09'
+      require 'bunny/exchange09'
+      require 'bunny/queue09'
+      require 'bunny/channel09'
+      require 'bunny/subscription09'
+
+      client = Bunny::Client09.new(*args)
+    end
+
+    include Qrack
+
+    client
+  end
+
+end