rabbitmq 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c4e267fdbae8d3ad4e67c1ad608a98f28ad53310
-  data.tar.gz: 11a314ccc79d99a1d1fadcb33c0b2faa5beca282
+  metadata.gz: a6084d87d4d4379929fbae34f8a6d7e8f979f176
+  data.tar.gz: 6312eaee4b20b758986c03fa8e448f763e03cb61
 SHA512:
-  metadata.gz: 22d8f50492ac62a77b12f403117db899939f00857275a66f2a769e367fa01bde2022fd929c0195e38c04d6b3d5ac88f71e61f6227dbbb0480e21762204617997
-  data.tar.gz: 112db78913fb348600cf4fd468b45274da40da276ea0cbbcd150ab6bc159c840793273cff30522ee6f5c70e60c16631762dd8e8a8131c14982e6a7a6e79de192
+  metadata.gz: 0de8d7059d8117341d3605ce4f58463fb912dc581572821cd9b3bcc80f82b3a5cb0ecfc5c3540dae0c6aeea1071027e4d6bc366ae651e04a76d9c60b788e836f
+  data.tar.gz: e09ce58387e226cd673b51a32934cb8456ba9eaddb00031cafddb7fafa84ea8acbd5657789645eb3388954c24072cf6a25b8e564f38071a7b3a60f2c91e0961d

data/ext/rabbitmq/Rakefile

@@ -32,7 +32,7 @@ file_task 'rabbitmq-c', :download => :download_tarball do
 end
 
 file_task 'config.status', :configure => :download do
-  system "bash -c 'cd #{FILES[:download]} && ./configure'"
+  system "bash -c 'cd #{FILES[:download]} && env CFLAGS=-g ./configure'"
   system "cp #{FILES[:download]}/#{FILES[:configure]} ./"
 end
 

data/lib/rabbitmq.rb

@@ -1,8 +1,11 @@
 
+require_relative 'rabbitmq/util'
+
 require_relative 'rabbitmq/ffi'
 require_relative 'rabbitmq/ffi/ext'
 require_relative 'rabbitmq/ffi/error'
 
-require_relative 'rabbitmq/util'
+require_relative 'rabbitmq/server_error'
 
 require_relative 'rabbitmq/connection'
+require_relative 'rabbitmq/channel'

data/lib/rabbitmq/channel.rb

@@ -0,0 +1,261 @@
+
+module RabbitMQ
+  class Channel
+    
+    attr_reader :connection
+    attr_reader :id
+    
+    # Don't create a {Channel} directly; call {Connection#channel} instead.
+    # @api private
+    def initialize(connection, id, pre_allocated: false)
+      @connection = connection
+      @id         = id
+      connection.send(:allocate_channel, id) unless pre_allocated
+      
+      @finalizer = self.class.send :create_finalizer_for, @connection, @id
+      ObjectSpace.define_finalizer self, @finalizer
+    end
+    
+    # Release the channel id to be reallocated to another {Channel} instance.
+    # This will be called automatically by the object finalizer after
+    # the object becomes unreachable by the VM and is garbage collected,
+    # but you may want to call it explicitly if you plan to reuse the same
+    # channel if in another {Channel} instance explicitly.
+    #
+    # @return [Channel] self.
+    #
+    def release
+      if @finalizer
+        @finalizer.call
+        ObjectSpace.undefine_finalizer self
+      end
+      @finalizer = nil
+      
+      self
+    end
+    
+    # @see {Connection#on_event}
+    def on(*args, &block)
+      @connection.on_event(@id, *args, &block)
+    end
+    
+    # @see {Connection#run_loop!}
+    def run_loop!(*args)
+      @connection.run_loop!(*args)
+    end
+    
+    # @see {Connection#break!}
+    def break!
+      @connection.break!
+    end
+    
+    # Create a finalizer not entangled with the {Channel} instance.
+    # @api private
+    def self.create_finalizer_for(connection, id)
+      Proc.new do
+        connection.send(:release_channel, id)
+      end
+    end
+    
+    private def rpc(request_type, params=[{}], response_type)
+      @connection.send_request(@id, request_type, params.last)
+      if response_type
+        @connection.fetch_response(@id, response_type)
+      else
+        true
+      end
+    end
+    
+    ##
+    # Exchange operations
+    
+    def exchange_declare(name, type, **opts)
+      rpc :exchange_declare, [
+        exchange:    name,
+        type:        type,
+        passive:     opts.fetch(:passive,     false),
+        durable:     opts.fetch(:durable,     false),
+        auto_delete: opts.fetch(:auto_delete, false),
+        internal:    opts.fetch(:internal,    false),
+      ], :exchange_declare_ok
+    end
+    
+    def exchange_delete(name, **opts)
+      rpc :exchange_delete, [
+        exchange:  name,
+        if_unused: opts.fetch(:if_unused, false),
+      ], :exchange_delete_ok
+    end
+    
+    def exchange_bind(source, destination, **opts)
+      rpc :exchange_bind, [
+        source:      source,
+        destination: destination,
+        routing_key: opts.fetch(:routing_key, ""),
+        arguments:   opts.fetch(:arguments,   {}),
+      ], :exchange_bind_ok
+    end
+    
+    def exchange_unbind(source, destination, **opts)
+      rpc :exchange_unbind, [
+        source:      source,
+        destination: destination,
+        routing_key: opts.fetch(:routing_key, ""),
+        arguments:   opts.fetch(:arguments,   {}),
+      ], :exchange_unbind_ok
+    end
+    
+    ##
+    # Queue operations
+    
+    def queue_declare(name, **opts)
+      rpc :queue_declare, [
+        queue:       name,
+        passive:     opts.fetch(:passive,     false),
+        durable:     opts.fetch(:durable,     false),
+        exclusive:   opts.fetch(:exclusive,   false),
+        auto_delete: opts.fetch(:auto_delete, false),
+        arguments:   opts.fetch(:arguments,   {}),
+      ], :queue_declare_ok
+    end
+    
+    def queue_bind(name, exchange, **opts)
+      rpc :queue_bind, [
+        queue:       name,
+        exchange:    exchange,
+        routing_key: opts.fetch(:routing_key, ""),
+        arguments:   opts.fetch(:arguments,   {}),
+      ], :queue_bind_ok
+    end
+    
+    def queue_unbind(name, exchange, **opts)
+      rpc :queue_unbind, [
+        queue:       name,
+        exchange:    exchange,
+        routing_key: opts.fetch(:routing_key, ""),
+        arguments:   opts.fetch(:arguments,   {}),
+      ], :queue_unbind_ok
+    end
+    
+    def queue_purge(name)
+      rpc :queue_purge, [queue: name], :queue_purge_ok
+    end
+    
+    def queue_delete(name, **opts)
+      rpc :queue_delete, [
+        queue:     name,
+        if_unused: opts.fetch(:if_unused, false),
+        if_empty:  opts.fetch(:if_empty,  false),
+      ], :queue_delete_ok
+    end
+    
+    ##
+    # Consumer operations
+    
+    def basic_qos(**opts)
+      rpc :basic_qos, [
+        prefetch_count: opts.fetch(:prefetch_count, 0),
+        prefetch_size:  opts.fetch(:prefetch_size,  0),
+        global:         opts.fetch(:global,         false),
+      ], :basic_qos_ok
+    end
+    
+    def basic_consume(queue, consumer_tag="", **opts)
+      rpc :basic_consume, [
+        queue:        queue,
+        consumer_tag: consumer_tag,
+        no_local:     opts.fetch(:no_local,  false),
+        no_ack:       opts.fetch(:no_ack,    false),
+        exclusive:    opts.fetch(:exclusive, false),
+        arguments:    opts.fetch(:arguments, {}),
+      ], :basic_consume_ok
+    end
+    
+    def basic_cancel(consumer_tag)
+      rpc :basic_cancel, [consumer_tag: consumer_tag], :basic_cancel_ok
+    end
+    
+    ##
+    # Transaction operations
+    
+    def tx_select
+      rpc :tx_select, [], :tx_select_ok
+    end
+    
+    def tx_commit
+      rpc :tx_commit, [], :tx_commit_ok
+    end
+    
+    def tx_rollback
+      rpc :tx_rollback, [], :tx_rollback_ok
+    end
+    
+    ##
+    # Message operations
+    
+    def basic_get(queue, **opts)
+      rpc :basic_get, [
+        queue:  queue,
+        no_ack: opts.fetch(:no_ack, false),
+      ], [:basic_get_ok, :basic_get_empty]
+    end
+    
+    def basic_ack(delivery_tag, **opts)
+      rpc :basic_ack, [
+        delivery_tag: delivery_tag,
+        multiple:     opts.fetch(:multiple, false),
+      ], nil
+    end
+    
+    def basic_nack(delivery_tag, **opts)
+      rpc :basic_nack, [
+        delivery_tag: delivery_tag,
+        multiple:     opts.fetch(:multiple, false),
+        requeue:      opts.fetch(:requeue, true),
+      ], nil
+    end
+    
+    def basic_reject(delivery_tag, **opts)
+      rpc :basic_reject, [
+        delivery_tag: delivery_tag,
+        requeue:      opts.fetch(:requeue, true),
+      ], nil
+    end
+    
+    def basic_publish(body, exchange, routing_key, **opts)
+      body        = FFI::Bytes.from_s(body, true)
+      exchange    = FFI::Bytes.from_s(exchange, true)
+      routing_key = FFI::Bytes.from_s(routing_key, true)
+      properties  = FFI::BasicProperties.new.apply(
+        content_type:       opts.fetch(:content_type,     "application/octet-stream"),
+        content_encoding:   opts.fetch(:content_encoding, ""),
+        headers:            opts.fetch(:headers,          {}),
+        delivery_mode:     (opts.fetch(:persistent,    false) ? :persistent : :nonpersistent),
+        priority:           opts.fetch(:priority,          0),
+        correlation_id:     opts.fetch(:correlation_id,   ""),
+        reply_to:           opts.fetch(:reply_to,         ""),
+        expiration:         opts.fetch(:expiration,       ""),
+        message_id:         opts.fetch(:message_id,       ""),
+        timestamp:          opts.fetch(:timestamp,         0),
+        type:               opts.fetch(:type,             ""),
+        user_id:            opts.fetch(:user_id,          ""),
+        app_id:             opts.fetch(:app_id,           ""),
+        cluster_id:         opts.fetch(:cluster_id,       "")
+      )
+      
+      Util.error_check :"publishing a message",
+        FFI.amqp_basic_publish(connection.send(:ptr), @id,
+          exchange,
+          routing_key,
+          opts.fetch(:mandatory, false),
+          opts.fetch(:immediate, false),
+          properties,
+          body
+        )
+      
+      properties.free!
+      true
+    end
+    
+  end
+end

data/lib/rabbitmq/connection.rb

@@ -1,9 +1,17 @@
 
+require 'socket'
+
 module RabbitMQ
   class Connection
     def initialize *args
-      @ptr = FFI.amqp_new_connection
-      parse_info(*args)
+      @ptr  = FFI.amqp_new_connection
+      @info = Util.connection_info(*args)
+      
+      @open_channels     = {}
+      @released_channels = {}
+      @event_handlers    = Hash.new { |h,k| h[k] = {} }
+      @incoming_events   = Hash.new { |h,k| h[k] = {} }
+      
       create_socket!
       
       @finalizer = self.class.send :create_finalizer_for, @ptr
@@ -35,37 +43,122 @@ module RabbitMQ
     def port;     @info[:port];     end
     def ssl?;     @info[:ssl];      end
     
-    def max_channels;   @max_channels   ||= 0;      end; attr_writer :max_channels
-    def max_frame_size; @max_frame_size ||= 131072; end; attr_writer :max_frame_size
+    def protocol_timeout
+      @protocol_timeout ||= 30 # seconds
+    end
+    attr_writer :protocol_timeout
+    
+    def max_channels
+      @max_channels ||= FFI::CHANNEL_MAX_ID
+    end
+    attr_writer :max_channels
+    
+    def max_frame_size
+      @max_frame_size ||= 131072
+    end
+    attr_writer :max_frame_size
+    
     def heartbeat_interval; 0; end # not fully implemented in librabbitmq
     
     def start
       close # Close if already open
       connect_socket!
       login!
-      open_channel!
+      
+      self
     end
     
     def close
       raise DestroyedError unless @ptr
       FFI.amqp_connection_close(@ptr, 200)
+      
+      release_all_channels
+      
+      self
     end
     
-    private def parse_info url=nil
-      info = FFI::ConnectionInfo.new
+    # Send a request on the given channel with the given type and properties.
+    #
+    # @param channel_id [Integer] The channel number to send on.
+    # @param method [Symbol] The type of protocol method to send.
+    # @param properties [Hash] The properties to apply to the method.
+    # @raise [RabbitMQ::FFI::Error] if a library exception occurs.
+    #
+    def send_request(channel_id, method, properties={})
+      Util.error_check :"sending a request",
+        send_request_internal(Integer(channel_id), method.to_sym, properties)
       
-      if url
-        url_ptr = Util.strdup_ptr(url)
-        Util.error_check :"parsing connection URL",
-          FFI.amqp_parse_url(url_ptr, info)
-        
-        # We must copy ConnectionInfo before the url_ptr is freed.
-        @info = info.to_h
-        url_ptr.free
-      else
-        FFI.amqp_default_connection_info(info)
-        @info = info.to_h
-      end
+      nil
+    end
+    
+    # Wait for a specific response on the given channel of the given type
+    # and return the event data for the response when it is received.
+    # Any other events received will be processed or stored internally.
+    #
+    # @param channel_id [Integer] The channel number to watch for.
+    # @param method [Symbol,Array<Symbol>] The protocol method(s) to watch for.
+    # @param timeout [Float] The maximum time to wait for a response in seconds;
+    #   uses the value of {#protocol_timeout} by default.
+    # @raise [RabbitMQ::ServerError] if any error event is received.
+    # @raise [RabbitMQ::FFI::Error::Timeout] if no event is received.
+    # @raise [RabbitMQ::FFI::Error] if a library exception occurs.
+    # @return [Hash] the response data received.
+    #
+    def fetch_response(channel_id, method, timeout=protocol_timeout)
+      methods = Array(method).map(&:to_sym)
+      fetch_response_internal(Integer(channel_id), methods, Float(timeout))
+    end
+    
+    # Register a handler for events on the given channel of the given type.
+    #
+    # @param channel_id [Integer] The channel number to watch for.
+    # @param method [Symbol] The type of protocol method to watch for.
+    # @param callable [#call,nil] The callable handler if no block is given.
+    # @param block [Proc,nil] The handler block to register.
+    # @return [Proc,#call] The given block or callable.
+    # @yieldparam event [Hash] The event passed to the handler.
+    #
+    def on_event(channel_id, method, callable=nil, &block)
+      handler = block || callable
+      raise ArgumentError, "expected block or callable as event handler" \
+        unless handler.respond_to?(:call)
+      
+      @event_handlers[Integer(channel_id)][method.to_sym] = handler
+      handler
+    end
+    
+    # Fetch and handle events in a loop that blocks the calling thread.
+    # The loop will continue until the {#break!} method is called from within
+    # an event handler, or until the given timeout duration has elapsed.
+    #
+    # @param timeout [Float] the maximum time to run the loop, in seconds;
+    #   if none is given, the loop will block indefinitely or until {#break!}.
+    #
+    def run_loop!(timeout=nil)
+      timeout = Float(timeout) if timeout
+      @breaking = false
+      fetch_events(timeout)
+      nil
+    end
+    
+    # Stop iterating from within an execution of the {#run_loop!} method.
+    # Call this method only from within an event handler.
+    # It will take effect only after the handler finishes running.
+    #
+    # @return [nil]
+    #
+    def break!
+      @breaking = true
+      nil
+    end
+    
+    def channel(id=nil)
+      Channel.new(self, allocate_channel(id), pre_allocated: true)
+    end
+    
+    private def ptr
+      raise DestroyedError unless @ptr
+      @ptr
     end
     
     private def create_socket!
@@ -82,31 +175,206 @@ module RabbitMQ
       create_socket!
       Util.error_check :"opening a socket",
         FFI.amqp_socket_open(@socket, host, port)
+      
+      @ruby_socket = Socket.for_fd(FFI.amqp_get_sockfd(@ptr))
+      @ruby_socket.autoclose = false
     end
     
     private def login!
       raise DestroyedError unless @ptr
       
-      rpc_check :"logging in",
-        FFI.amqp_login(@ptr, vhost, max_channels, max_frame_size,
-          heartbeat_interval, :plain, :string, user, :string, password)
+      res = FFI.amqp_login(@ptr, vhost, max_channels, max_frame_size,
+        heartbeat_interval, :plain, :string, user, :string, password)
+      
+      case res[:reply_type]
+      when :library_exception; Util.error_check :"logging in", res[:library_error]
+      when :server_exception;  raise NotImplementedError
+      end
       
       @server_properties = FFI::Table.new(FFI.amqp_get_server_properties(@ptr)).to_h
     end
     
-    private def open_channel!(number=1)
+    private def open_channel(id)
+      Util.error_check :"opening a new channel",
+        send_request_internal(id, :channel_open)
+      
+      fetch_response(id, :channel_open_ok)
+    end
+    
+    private def reopen_channel(id)
+      Util.error_check :"acknowledging server-initated channel closure",
+        send_request_internal(id, :channel_close_ok)
+      
+      Util.error_check :"reopening channel after server-initated closure",
+        send_request_internal(id, :channel_open)
+      
+      fetch_response(id, :channel_open_ok)
+    end
+    
+    private def allocate_channel(id=nil)
+      if id
+        raise ArgumentError, "channel #{id} is already in use" if @open_channels[id]
+      elsif @released_channels.empty?
+        id = (@open_channels.keys.sort.last || 0) + 1
+      else
+        id = @released_channels.keys.first
+      end
+      raise ArgumentError, "channel #{id} is too high" if id > max_channels
+      
+      already_open = @released_channels.delete(id)
+      open_channel(id) unless already_open
+      
+      @open_channels[id] = true
+      @event_handlers[id] ||= {}
+      
+      id
+    end
+    
+    private def release_channel(id)
+      @open_channels.delete(id)
+      @event_handlers.delete(id)
+      @released_channels[id] = true
+    end
+    
+    private def release_all_channels
+      @open_channels.clear
+      @event_handlers.clear
+      @released_channels.clear
+    end
+    
+    # Block until there is readable data on the internal ruby socket,
+    # returning true if there is readable data, or false if time expired.
+    private def select(timeout=0, start=Time.now)
+      if timeout
+        timeout = timeout - (start-Time.now)
+        timeout = 0 if timeout < 0
+      end
+      
+      IO.select([@ruby_socket], [], [], timeout) ? true : false
+    end
+    
+    # Return the next available frame, or nil if time expired.
+    private def fetch_next_frame(timeout=0, start=Time.now)
+      frame  = FFI::Frame.new
+      
+      # Try fetching the next frame without a blocking call.
+      status = FFI.amqp_simple_wait_frame_noblock(@ptr, frame, FFI::Timeval.zero)
+      case status
+      when :ok;      return frame
+      when :timeout; # do nothing and proceed to waiting on select below
+      else Util.error_check :"fetching the next frame", status
+      end
+      
+      # Otherwise, wait for the socket to be readable and try fetching again.
+      return nil unless select(timeout, start)
+      Util.error_check :"fetching the next frame",
+        FFI.amqp_simple_wait_frame(@ptr, frame)
+      
+      frame
+    end
+    
+    # Fetch the next one or more frames to form the next discrete event,
+    # returning the event as a Hash, or nil if time expired.
+    private def fetch_next_event(timeout=0, start=Time.now)
+      frame = fetch_next_frame(timeout, start)
+      return unless frame
+      event = frame.as_method_to_h(false)
+      return event unless FFI::Method.has_content?(event.fetch(:method))
+      
+      frame = fetch_next_frame(timeout, start)
+      return unless frame
+      event.merge!(frame.as_header_to_h)
+      
+      body = ""
+      while body.size < event.fetch(:body_size)
+        frame = fetch_next_frame(timeout, start)
+        return unless frame
+        body.concat frame.as_body_to_s
+      end
+      
+      event[:body] = body
+      event
+    end
+    
+    # Execute the handler for this type of event, if any
+    private def handle_incoming_event(event)
+      if (handlers = @event_handlers[event.fetch(:channel)])
+        if (handler = (handlers[event.fetch(:method)]))
+          handler.call(event)
+        end
+      end
+    end
+    
+    # Store the event in short-term storage for retrieval by fetch_response.
+    # If another event is received with the same method name, it will
+    # overwrite this one - fetch_response gets the latest or next by method.
+    # Raises an exception if the incoming event is an error condition.
+    private def store_incoming_event(event)
+      method  = event.fetch(:method)
+      
+      case method
+      when :channel_close
+        raise_if_server_error!(event)
+      when :connection_close
+        raise_if_server_error!(event)
+      else
+        @incoming_events[event.fetch(:channel)][method] = event
+      end
+    end
+    
+    # Raise an exception if the incoming event is an error condition.
+    # Also takes action to reopen the channel or close the connection.
+    private def raise_if_server_error!(event)
+      if (exc = ServerError.from(event))
+        if exc.is_a?(ServerError::ChannelError)
+          reopen_channel(event.fetch(:channel)) # recover by reopening the channel
+        elsif exc.is_a?(ServerError::ConnectionError)
+          close # can't recover here - close and let the user recover manually
+        end
+        raise exc
+      end
+    end
+    
+    private def fetch_events(timeout=protocol_timeout, start=Time.now)
       raise DestroyedError unless @ptr
       
-      FFI.amqp_channel_open(@ptr, number)
-      rpc_check :"opening channel", FFI.amqp_get_rpc_reply(@ptr)
+      FFI.amqp_maybe_release_buffers(@ptr)
+      
+      while (event = fetch_next_event(timeout, start))
+        handle_incoming_event(event)
+        store_incoming_event(event)
+        break if @breaking
+      end
     end
     
-    private def rpc_check action, res
-      case res[:reply_type]
-      when :library_exception; Util.error_check action, res[:library_error]
-      when :server_exception;  raise NotImplementedError
-      else res
+    private def fetch_response_internal(channel, methods, timeout=protocol_timeout, start=Time.now)
+      raise DestroyedError unless @ptr
+      
+      methods.each { |method|
+        found = @incoming_events[channel].delete(method)
+        return found if found
+      }
+      
+      FFI.amqp_maybe_release_buffers_on_channel(@ptr, channel)
+      
+      while (event = fetch_next_event(timeout, start))
+        handle_incoming_event(event)
+        return event if channel == event.fetch(:channel) \
+                     && methods.include?(event.fetch(:method))
+        store_incoming_event(event)
       end
+      
+      raise FFI::Error::Timeout, "waiting for response"
+    end
+    
+    private def send_request_internal(channel_id, method, properties={})
+      raise DestroyedError unless @ptr
+      
+      req    = FFI::Method.lookup_class(method).new.apply(properties)
+      status = FFI.amqp_send_method(@ptr, channel_id, method, req.pointer)
+      
+      req.free!
+      status
     end
   end
 end