rabbitmq 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eb846b463a46e8d88e17f6ee64caab80faa6b1b5
-  data.tar.gz: 7f4107feb512e7aa9abae32264536623453baa6e
+  metadata.gz: 7a316aadf277e65f4cdc221c69968f5384857db0
+  data.tar.gz: d60a1d8a3f037ecf5c34680ee4ae53dc8573f0d1
 SHA512:
-  metadata.gz: 1ea282404a15b85ce764bd989e12f14bc2b7f2d604d57351fc5545eae25de47531bb9ab5661aab657ecd0f428f8bf6c0c5b4b8a46ea29a5263ae8b5fa35f3124
-  data.tar.gz: 6b22c1156bec01feaf4cec670ad2222011680485db27110818f3fc12a7909698ceb9109029de4f7dc14668a3d630e2d622af06b805b3291ac4ae3fefdd78373a
+  metadata.gz: a4c2d7de59bc0f09122c77c3af96c6ff2bb04c16af0de3aa5b495d44bff738445205405d3a5a4b87e51b50cf7b51273c36b077165988a4d951974ae3bd6c5f1e
+  data.tar.gz: ea4f0cfe51575d0d7a2caa1411bf51bc650466197f41caab43cc858db5cba7d3e865b0ae7088e5cc6745e0cd2d1114ae61da66d6baddbbcd395dd527e446b0b6

data/README.md

@@ -1,3 +1,6 @@
 # rabbitmq
 
+[![Build Status](https://travis-ci.org/jemc/ruby-rabbitmq.png)](https://travis-ci.org/jemc/ruby-rabbitmq)
+[![Gem Version](https://badge.fury.io/rb/rabbitmq.png)](http://badge.fury.io/rb/rabbitmq)
+
 A Ruby RabbitMQ client library based on FFI bindings for librabbitmq.

data/ext/rabbitmq/Rakefile

@@ -1,5 +1,6 @@
 
 require 'rake/clean'
+require 'ffi'
 
 FILES = {}
 
@@ -19,24 +20,28 @@ def self.file_task(filename, opts, &block)
   end
 end
 
+def cmd(string)
+  fail "Command failed: #{string}" unless system(string)
+end
+
 file_task 'rabbitmq-c.tar.gz', :download_tarball do
   version = "0.6.0"
   release = "https://github.com/alanxz/rabbitmq-c/releases/download/v#{version}/rabbitmq-c-#{version}.tar.gz"
-  system "wget #{release}"
-  system "mv #{File.basename(release)} #{FILES[:download_tarball]}"
+  cmd "wget #{release}"
+  cmd "mv #{File.basename(release)} #{FILES[:download_tarball]}"
 end
 
 file_task 'rabbitmq-c', :download => :download_tarball do
-  system "tar -xf #{FILES[:download_tarball]}"
-  system "mv rabbitmq-c-* #{FILES[:download]}"
+  cmd "tar -xf #{FILES[:download_tarball]}"
+  cmd "mv rabbitmq-c-* #{FILES[:download]}"
 end
 
 file_task 'config.status', :configure => :download do
-  system "bash -c 'cd #{FILES[:download]} && env CFLAGS=-g ./configure'"
-  system "cp #{FILES[:download]}/#{FILES[:configure]} ./"
+  cmd "bash -c 'cd #{FILES[:download]} && env CFLAGS=-g ./configure'"
+  cmd "cp #{FILES[:download]}/#{FILES[:configure]} ./"
 end
 
-file_task 'librabbitmq.so', :build => :configure do
-  system "bash -c 'cd #{FILES[:download]} && make'"
-  system "cp #{FILES[:download]}/librabbitmq/.libs/#{FILES[:build]} ."
+file_task "librabbitmq.#{::FFI::Platform::LIBSUFFIX}", :build => :configure do
+  cmd "bash -c 'cd #{FILES[:download]} && make'"
+  cmd "cp #{FILES[:download]}/librabbitmq/.libs/#{FILES[:build]} ."
 end

data/lib/rabbitmq/connection/channel_manager.rb

@@ -0,0 +1,61 @@
+
+module RabbitMQ
+  class Connection
+    
+    class ChannelManager
+      def initialize(connection)
+        @connection = connection
+        @open_channels     = {}
+        @released_channels = {}
+      end
+      
+      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 > @connection.max_channels
+        
+        already_open = @released_channels.delete(id)
+        request_channel_open(id) unless already_open
+        
+        @open_channels[id] = true
+        @event_handlers[id] ||= {}
+        
+        id
+      end
+      
+      def release_channel(id)
+        @open_channels.delete(id)
+        @released_channels[id] = true
+      end
+      
+      def release_all_channels
+        @open_channels.clear
+        @released_channels.clear
+      end
+      
+      def request_channel_open(id)
+        Util.error_check :"opening a new channel",
+          @connection.send_request_internal(id, :channel_open)
+        
+        @connection.fetch_response(id, :channel_open_ok)
+      end
+      
+      def request_channel_reopen(id)
+        Util.error_check :"acknowledging server-initated channel closure",
+          @connection.send_request_internal(id, :channel_close_ok)
+        
+        Util.error_check :"reopening channel after server-initated closure",
+          @connection.send_request_internal(id, :channel_open)
+        
+        @connection.fetch_response(id, :channel_open_ok)
+      end
+      
+    end
+    
+  end
+end

data/lib/rabbitmq/connection/event_manager.rb

@@ -0,0 +1,55 @@
+
+module RabbitMQ
+  class Connection
+    
+    class EventManager
+      def initialize(connection)
+        @connection = connection
+        @event_handlers  = Hash.new { |h,k| h[k] = {} }
+        @incoming_events = Hash.new { |h,k| h[k] = {} }
+      end
+      
+      def register_handler(id, method, handler)
+        @event_handlers[id][method] = handler
+      end
+      
+      def clear_event_handlers(id)
+        @event_handlers.delete(id)
+      end
+      
+      def clear_all_event_handlers
+        @event_handlers.clear
+      end
+      
+      # Execute the handler for this type of event, if any
+      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.
+      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
+      
+      def fetch_stored_event(channel_id, method)
+        @incoming_events[channel_id].delete(method)
+      end
+    end
+    
+  end
+end

data/lib/rabbitmq/connection/transport.rb

@@ -0,0 +1,157 @@
+
+require 'socket'
+
+module RabbitMQ
+  class Connection
+    
+    class DestroyedError < RuntimeError; end
+    
+    class Transport
+      
+      attr_reader :ptr
+      
+      def initialize(connnection)
+        @ptr = FFI.amqp_new_connection
+        @frame = FFI::Frame.new
+        @connection = connnection
+        
+        create_socket!
+        
+        @finalizer = self.class.create_finalizer_for(@ptr)
+        ObjectSpace.define_finalizer(self, @finalizer)
+      end
+      
+      def destroy
+        if @finalizer
+          @finalizer.call
+          ObjectSpace.undefine_finalizer(self)
+        end
+        @ptr = @socket = @finalizer = nil
+      end
+      
+      # @private
+      def self.create_finalizer_for(ptr)
+        Proc.new do
+          FFI.amqp_connection_close(ptr, 200)
+          FFI.amqp_destroy_connection(ptr)
+        end
+      end
+      
+      def ptr
+        raise DestroyedError unless @ptr
+        @ptr
+      end
+      
+      def close
+        raise DestroyedError unless @ptr
+        FFI.amqp_connection_close(@ptr, 200)
+      end
+      
+      def create_socket!
+        raise DestroyedError unless @ptr
+        
+        @socket = FFI.amqp_tcp_socket_new(@ptr)
+        Util.null_check :"creating a socket", @socket
+      end
+      
+      def connect_socket!
+        raise DestroyedError unless @ptr
+        raise NotImplementedError if @connection.ssl?
+        
+        create_socket!
+        Util.error_check :"opening a socket",
+          FFI.amqp_socket_open(@socket, @connection.host, @connection.port)
+        
+        @ruby_socket = Socket.for_fd(FFI.amqp_get_sockfd(@ptr))
+        @ruby_socket.autoclose = false
+      end
+      
+      def login!
+        raise DestroyedError unless @ptr
+        
+        res = FFI.amqp_login(@ptr, @connection.vhost,
+          @connection.max_channels, @connection.max_frame_size,
+          @connection.heartbeat_interval, :plain,
+          :string, @connection.user, :string, @connection.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
+      
+      # Block until there is readable data on the internal ruby socket,
+      # returning true if there is readable data, or false if time expired.
+      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.
+      def fetch_next_frame(timeout=0, start=Time.now)
+        frame = @frame
+        
+        # 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.
+      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
+      
+      def send_method(channel_id, method, properties={})
+        req    = FFI::Method.lookup_class(method).new.apply(properties)
+        status = FFI.amqp_send_method(ptr, channel_id, method, req.pointer)
+        
+        req.free!
+        status
+      end
+      
+      def garbage_collect
+        FFI.amqp_maybe_release_buffers(ptr)
+      end
+      
+      def garbage_collect_channel(channel_id)
+        FFI.amqp_maybe_release_buffers_on_channel(ptr, channel_id)
+      end
+    end
+    
+  end
+end

data/lib/rabbitmq/ffi.rb

@@ -6,9 +6,11 @@ module RabbitMQ
   module FFI
     extend ::FFI::Library
     
+    libfile = "librabbitmq.#{::FFI::Platform::LIBSUFFIX}"
+    
     ffi_lib ::FFI::Library::LIBC
     ffi_lib \
-      File.expand_path("../../ext/rabbitmq/librabbitmq.so", File.dirname(__FILE__))
+      File.expand_path("../../ext/rabbitmq/#{libfile}", File.dirname(__FILE__))
     
     begin # TODO: remove begin/end block
       opts = {
@@ -289,361 +291,7 @@ module RabbitMQ
       attach_function :amqp_encode_method,      [MethodNumber, :pointer, Bytes.val],           Status,  **opts
       attach_function :amqp_encode_properties,  [:uint16, :pointer, Bytes.val],                Status,  **opts
       
-      class ConnectionStart < ::FFI::Struct
-        layout :version_major,     :uint8,
-               :version_minor,     :uint8,
-               :server_properties, Table,
-               :mechanisms,        Bytes,
-               :locales,           Bytes
-      end
-      
-      class ConnectionStartOk < ::FFI::Struct
-        layout :client_properties, Table,
-               :mechanism,         Bytes,
-               :response,          Bytes,
-               :locale,            Bytes
-      end
-      
-      class ConnectionSecure < ::FFI::Struct
-        layout :challenge, Bytes
-      end
-      
-      class ConnectionSecureOk < ::FFI::Struct
-        layout :response, Bytes
-      end
-      
-      class ConnectionTune < ::FFI::Struct
-        layout :channel_max, :uint16,
-               :frame_max,   :uint32,
-               :heartbeat,   :uint16
-      end
-      
-      class ConnectionTuneOk < ::FFI::Struct
-        layout :channel_max, :uint16,
-               :frame_max,   :uint32,
-               :heartbeat,   :uint16
-      end
-      
-      class ConnectionOpen < ::FFI::Struct
-        layout :virtual_host, Bytes,
-               :capabilities, Bytes,
-               :insist,       Boolean
-      end
-      
-      class ConnectionOpenOk < ::FFI::Struct
-        layout :known_hosts, Bytes
-      end
-      
-      class ConnectionClose < ::FFI::Struct
-        layout :reply_code, :uint16,
-               :reply_text, Bytes,
-               :class_id,   :uint16,
-               :method_id,  :uint16
-      end
-      
-      class ConnectionCloseOk < ::FFI::Struct
-        layout :dummy, :char
-      end
-      
-      class ConnectionBlocked < ::FFI::Struct
-        layout :reason, Bytes
-      end
-      
-      class ConnectionUnblocked < ::FFI::Struct
-        layout :dummy, :char
-      end
-      
-      class ChannelOpen < ::FFI::Struct
-        layout :out_of_band, Bytes
-      end
-      
-      class ChannelOpenOk < ::FFI::Struct
-        layout :channel_id, Bytes
-      end
-      
-      class ChannelFlow < ::FFI::Struct
-        layout :active, Boolean
-      end
-      
-      class ChannelFlowOk < ::FFI::Struct
-        layout :active, Boolean
-      end
-      
-      class ChannelClose < ::FFI::Struct
-        layout :reply_code, :uint16,
-               :reply_text, Bytes,
-               :class_id,   :uint16,
-               :method_id,  :uint16
-      end
-      
-      class ChannelCloseOk < ::FFI::Struct
-        layout :dummy, :char
-      end
-      
-      class AccessRequest < ::FFI::Struct
-        layout :realm,     Bytes,
-               :exclusive, Boolean,
-               :passive,   Boolean,
-               :active,    Boolean,
-               :write,     Boolean,
-               :read,      Boolean
-      end
-      
-      class AccessRequestOk < ::FFI::Struct
-        layout :ticket, :uint16
-      end
-      
-      class ExchangeDeclare < ::FFI::Struct
-        layout :ticket,      :uint16,
-               :exchange,    Bytes,
-               :type,        Bytes,
-               :passive,     Boolean,
-               :durable,     Boolean,
-               :auto_delete, Boolean,
-               :internal,    Boolean,
-               :nowait,      Boolean,
-               :arguments,   Table
-      end
-      
-      class ExchangeDeclareOk < ::FFI::Struct
-        layout :dummy, :char
-      end
-      
-      class ExchangeDelete < ::FFI::Struct
-        layout :ticket,    :uint16,
-               :exchange,  Bytes,
-               :if_unused, Boolean,
-               :nowait,    Boolean
-      end
-      
-      class ExchangeDeleteOk < ::FFI::Struct
-        layout :dummy, :char
-      end
-      
-      class ExchangeBind < ::FFI::Struct
-        layout :ticket,      :uint16,
-               :destination, Bytes,
-               :source,      Bytes,
-               :routing_key, Bytes,
-               :nowait,      Boolean,
-               :arguments,   Table
-      end
-      
-      class ExchangeBindOk < ::FFI::Struct
-        layout :dummy, :char
-      end
-      
-      class ExchangeUnbind < ::FFI::Struct
-        layout :ticket,      :uint16,
-               :destination, Bytes,
-               :source,      Bytes,
-               :routing_key, Bytes,
-               :nowait,      Boolean,
-               :arguments,   Table
-      end
-      
-      class ExchangeUnbindOk < ::FFI::Struct
-        layout :dummy, :char
-      end
-      
-      class QueueDeclare < ::FFI::Struct
-        layout :ticket,      :uint16,
-               :queue,       Bytes,
-               :passive,     Boolean,
-               :durable,     Boolean,
-               :exclusive,   Boolean,
-               :auto_delete, Boolean,
-               :nowait,      Boolean,
-               :arguments,   Table
-      end
-      
-      class QueueDeclareOk < ::FFI::Struct
-        layout :queue,          Bytes,
-               :message_count,  :uint32,
-               :consumer_count, :uint32
-      end
-      
-      class QueueBind < ::FFI::Struct
-        layout :ticket,      :uint16,
-               :queue,       Bytes,
-               :exchange,    Bytes,
-               :routing_key, Bytes,
-               :nowait,      Boolean,
-               :arguments,   Table
-      end
-      
-      class QueueBindOk < ::FFI::Struct
-        layout :dummy, :char
-      end
-      
-      class QueuePurge < ::FFI::Struct
-        layout :ticket, :uint16,
-               :queue,  Bytes,
-               :nowait, Boolean
-      end
-      
-      class QueuePurgeOk < ::FFI::Struct
-        layout :message_count, :uint32
-      end
-      
-      class QueueDelete < ::FFI::Struct
-        layout :ticket,    :uint16,
-               :queue,     Bytes,
-               :if_unused, Boolean,
-               :if_empty,  Boolean,
-               :nowait,    Boolean
-      end
-      
-      class QueueDeleteOk < ::FFI::Struct
-        layout :message_count, :uint32
-      end
-      
-      class QueueUnbind < ::FFI::Struct
-        layout :ticket,      :uint16,
-               :queue,       Bytes,
-               :exchange,    Bytes,
-               :routing_key, Bytes,
-               :arguments,   Table
-      end
-      
-      class QueueUnbindOk < ::FFI::Struct
-        layout :dummy, :char
-      end
-      
-      class BasicQos < ::FFI::Struct
-        layout :prefetch_size,  :uint32,
-               :prefetch_count, :uint16,
-               :global,         Boolean
-      end
-      
-      class BasicQosOk < ::FFI::Struct
-        layout :dummy, :char
-      end
-      
-      class BasicConsume < ::FFI::Struct
-        layout :ticket,       :uint16,
-               :queue,        Bytes,
-               :consumer_tag, Bytes,
-               :no_local,     Boolean,
-               :no_ack,       Boolean,
-               :exclusive,    Boolean,
-               :nowait,       Boolean,
-               :arguments,    Table
-      end
-      
-      class BasicConsumeOk < ::FFI::Struct
-        layout :consumer_tag, Bytes
-      end
-      
-      class BasicCancel < ::FFI::Struct
-        layout :consumer_tag, Bytes,
-               :nowait,       Boolean
-      end
-      
-      class BasicCancelOk < ::FFI::Struct
-        layout :consumer_tag, Bytes
-      end
-      
-      class BasicPublish < ::FFI::Struct
-        layout :ticket,      :uint16,
-               :exchange,    Bytes,
-               :routing_key, Bytes,
-               :mandatory,   Boolean,
-               :immediate,   Boolean
-      end
-      
-      class BasicReturn < ::FFI::Struct
-        layout :reply_code,  :uint16,
-               :reply_text,  Bytes,
-               :exchange,    Bytes,
-               :routing_key, Bytes
-      end
-      
-      class BasicDeliver < ::FFI::Struct
-        layout :consumer_tag, Bytes,
-               :delivery_tag, :uint64,
-               :redelivered,  Boolean,
-               :exchange,     Bytes,
-               :routing_key,  Bytes
-      end
-      
-      class BasicGet < ::FFI::Struct
-        layout :ticket, :uint16,
-               :queue,  Bytes,
-               :no_ack, Boolean
-      end
-      
-      class BasicGetOk < ::FFI::Struct
-        layout :delivery_tag,  :uint64,
-               :redelivered,   Boolean,
-               :exchange,      Bytes,
-               :routing_key,   Bytes,
-               :message_count, :uint32
-      end
-      
-      class BasicGetEmpty < ::FFI::Struct
-        layout :cluster_id, Bytes
-      end
-      
-      class BasicAck < ::FFI::Struct
-        layout :delivery_tag, :uint64,
-               :multiple,     Boolean
-      end
-      
-      class BasicReject < ::FFI::Struct
-        layout :delivery_tag, :uint64,
-               :requeue,      Boolean
-      end
-      
-      class BasicRecoverAsync < ::FFI::Struct
-        layout :requeue, Boolean
-      end
-      
-      class BasicRecover < ::FFI::Struct
-        layout :requeue, Boolean
-      end
-      
-      class BasicRecoverOk < ::FFI::Struct
-        layout :dummy, :char
-      end
-      
-      class BasicNack < ::FFI::Struct
-        layout :delivery_tag, :uint64,
-               :multiple, Boolean,
-               :requeue, Boolean
-      end
-      
-      class TxSelect < ::FFI::Struct
-        layout :dummy, :char
-      end
-      
-      class TxSelectOk < ::FFI::Struct
-        layout :dummy, :char
-      end
-      
-      class TxCommit < ::FFI::Struct
-        layout :dummy, :char
-      end
-      
-      class TxCommitOk < ::FFI::Struct
-        layout :dummy, :char
-      end
-      
-      class TxRollback < ::FFI::Struct
-        layout :dummy, :char
-      end
-      
-      class TxRollbackOk < ::FFI::Struct
-        layout :dummy, :char
-      end
-      
-      class ConfirmSelect < ::FFI::Struct
-        layout :nowait, Boolean
-      end
-      
-      class ConfirmSelectOk < ::FFI::Struct
-        layout :dummy, :char
-      end
+      require_relative 'ffi/gen'
       
       class ConnectionProperties < ::FFI::Struct
         layout :flags, Flags,