rabbitmq 0.2.3 → 0.2.4

data/lib/rabbitmq/ffi/ext/frame.rb

@@ -0,0 +1,43 @@
+
+module RabbitMQ
+  module FFI
+    
+    class Frame
+      def payload
+        member = case self[:frame_type]
+        when :method; :method
+        when :header; :properties
+        when :body;   :body_fragment
+        else; raise NotImplementedError, "frame type: #{self[:frame_type]}"
+        end
+        self[:payload][member]
+      end
+      
+      def as_method_to_h(free=false)
+        # TODO: raise correct error class with enough info for appropriate action
+        raise "Wrong frame type for method frame of event: #{self[:frame_type]}" \
+          unless self[:frame_type] == :method
+        
+        payload.to_h(free).merge(channel: self[:channel])
+      end
+      
+      def as_header_to_h(free=false)
+        # TODO: raise correct error class with enough info for appropriate action
+        raise "Wrong frame type for header frame of multiframe event: #{self[:frame_type]}" \
+          unless self[:frame_type] == :header
+        
+        properties = self[:payload][:properties]
+        { header: properties.decoded.to_h(free), body_size: properties[:body_size] }
+      end
+      
+      def as_body_to_s(free=false)
+        # TODO: raise correct error class with enough info for appropriate action
+        raise "Wrong frame type for body frame of multiframe event: #{self[:frame_type]}" \
+          unless self[:frame_type] == :body
+        
+        self[:payload][:body_fragment].to_s(free)
+      end
+    end
+    
+  end
+end

data/lib/rabbitmq/ffi/ext/frame_payload_properties.rb

@@ -0,0 +1,12 @@
+
+module RabbitMQ
+  module FFI
+    
+    class FramePayloadProperties
+      def decoded
+        BasicProperties.new(self[:decoded])
+      end
+    end
+    
+  end
+end

data/lib/rabbitmq/ffi/ext/method.rb

@@ -0,0 +1,49 @@
+
+module RabbitMQ
+  module FFI
+    
+    class Method
+      MethodClasses = FFI::MethodNumber.symbols.map do |name|
+        const_name = name.to_s.gsub(/((?:\A\w)|(?:_\w))/) { |x| x[-1].upcase }
+        [name, FFI.const_get(const_name)]
+      end.to_h.freeze
+      
+      MethodNames = MethodClasses.to_a.map(&:reverse).to_h.freeze
+      
+      def to_h(free=false)
+        { method: self[:id],
+          properties: self.decoded.to_h(free) }
+      end
+      
+      def decoded
+        MethodClasses.fetch(self[:id]).new(self[:decoded])
+      end
+      
+      def self.lookup(kls)
+        MethodNames.fetch(kls)
+      end
+      
+      def self.lookup_class(name)
+        MethodClasses.fetch(name)
+      end
+      
+      def self.from(decoded)
+        obj = new
+        obj[:id] = lookup(decoded.class)
+        obj[:decoded] = decoded.pointer
+        obj
+      end
+      
+      def self.has_content?(type)
+        case type
+        when :basic_publish; true
+        when :basic_return;  true
+        when :basic_deliver; true
+        when :basic_get_ok;  true
+        else                 false
+        end
+      end
+    end
+    
+  end
+end

data/lib/rabbitmq/ffi/ext/table.rb

@@ -0,0 +1,51 @@
+
+module RabbitMQ
+  module FFI
+    
+    class Table
+      include Enumerable
+      
+      def each(*a, &b)
+        entry_ptr = self[:entries]
+        entries   = self[:num_entries].times.map do |i|
+          FFI::TableEntry.new(entry_ptr + i * FFI::TableEntry.size)
+        end
+        entries.each(*a, &b)
+      end
+      
+      def to_h(free=false)
+        result = self.map do |entry|
+          [entry[:key].to_s(free), entry[:value].to_value(free)]
+        end.to_h
+        
+        clear if free
+        result
+      end
+      
+      def free!
+        self.each do
+          entry[:key].free!
+          entry[:value].free!
+        end
+        FFI.free(self[:entries])
+        clear
+      end
+      
+      def self.from(params)
+        size      = params.size
+        entry_ptr = Util.mem_ptr(size * FFI::TableEntry.size, release: false)
+        params.each_with_index do |param, idx|
+          entry = FFI::TableEntry.new(entry_ptr + idx * FFI::TableEntry.size)
+          entry[:key]   = FFI::Bytes.from_s(param.first.to_s)
+          entry[:value] = FFI::FieldValue.from(param.last)
+        end
+        
+        obj = new
+        obj[:num_entries] = size
+        obj[:entries]     = entry_ptr
+        obj
+      end
+    end
+    
+  end
+end

data/lib/rabbitmq/ffi/ext/timeval.rb

@@ -0,0 +1,18 @@
+
+module RabbitMQ
+  module FFI
+    
+    class Timeval
+      def self.from(seconds)
+        obj = new
+        obj[:tv_sec] = Integer(seconds)
+        obj[:tv_usec] = Integer(Float(seconds) * 1_000_000)
+        obj
+      end
+      
+      @zero = self.from(0)
+      class << self; attr_reader :zero; end
+    end
+    
+  end
+end

data/lib/rabbitmq/ffi/gen.rb

@@ -0,0 +1,65 @@
+
+require_relative 'gen/connection_start'
+require_relative 'gen/connection_start_ok'
+require_relative 'gen/connection_secure'
+require_relative 'gen/connection_secure_ok'
+require_relative 'gen/connection_tune'
+require_relative 'gen/connection_tune_ok'
+require_relative 'gen/connection_open'
+require_relative 'gen/connection_open_ok'
+require_relative 'gen/connection_close'
+require_relative 'gen/connection_close_ok'
+require_relative 'gen/connection_blocked'
+require_relative 'gen/connection_unblocked'
+require_relative 'gen/channel_open'
+require_relative 'gen/channel_open_ok'
+require_relative 'gen/channel_flow'
+require_relative 'gen/channel_flow_ok'
+require_relative 'gen/channel_close'
+require_relative 'gen/channel_close_ok'
+require_relative 'gen/access_request'
+require_relative 'gen/access_request_ok'
+require_relative 'gen/exchange_declare'
+require_relative 'gen/exchange_declare_ok'
+require_relative 'gen/exchange_delete'
+require_relative 'gen/exchange_delete_ok'
+require_relative 'gen/exchange_bind'
+require_relative 'gen/exchange_bind_ok'
+require_relative 'gen/exchange_unbind'
+require_relative 'gen/exchange_unbind_ok'
+require_relative 'gen/queue_declare'
+require_relative 'gen/queue_declare_ok'
+require_relative 'gen/queue_bind'
+require_relative 'gen/queue_bind_ok'
+require_relative 'gen/queue_purge'
+require_relative 'gen/queue_purge_ok'
+require_relative 'gen/queue_delete'
+require_relative 'gen/queue_delete_ok'
+require_relative 'gen/queue_unbind'
+require_relative 'gen/queue_unbind_ok'
+require_relative 'gen/basic_qos'
+require_relative 'gen/basic_qos_ok'
+require_relative 'gen/basic_consume'
+require_relative 'gen/basic_consume_ok'
+require_relative 'gen/basic_cancel'
+require_relative 'gen/basic_cancel_ok'
+require_relative 'gen/basic_publish'
+require_relative 'gen/basic_return'
+require_relative 'gen/basic_deliver'
+require_relative 'gen/basic_get'
+require_relative 'gen/basic_get_ok'
+require_relative 'gen/basic_get_empty'
+require_relative 'gen/basic_ack'
+require_relative 'gen/basic_reject'
+require_relative 'gen/basic_recover_async'
+require_relative 'gen/basic_recover'
+require_relative 'gen/basic_recover_ok'
+require_relative 'gen/basic_nack'
+require_relative 'gen/tx_select'
+require_relative 'gen/tx_select_ok'
+require_relative 'gen/tx_commit'
+require_relative 'gen/tx_commit_ok'
+require_relative 'gen/tx_rollback'
+require_relative 'gen/tx_rollback_ok'
+require_relative 'gen/confirm_select'
+require_relative 'gen/confirm_select_ok'

data/lib/rabbitmq/ffi/gen/access_request.rb

@@ -0,0 +1,49 @@
+
+module RabbitMQ
+  module FFI
+    class AccessRequest < ::FFI::Struct
+      layout(
+        :realm, Bytes,
+        :exclusive, Boolean,
+        :passive, Boolean,
+        :active, Boolean,
+        :write, Boolean,
+        :read, Boolean
+      )
+      
+      def self.id
+        :access_request
+      end
+      
+      def id
+        :access_request
+      end
+      
+      def apply(realm: nil, exclusive: nil, passive: nil, active: nil, write: nil, read: nil)
+        self[:realm] = Bytes.from_s(realm.to_s) if realm
+        self[:exclusive] = exclusive unless exclusive.nil?
+        self[:passive] = passive unless passive.nil?
+        self[:active] = active unless active.nil?
+        self[:write] = write unless write.nil?
+        self[:read] = read unless read.nil?
+        self
+      end
+      
+      def to_h(free=false)
+        {
+          realm: self[:realm].to_s(free),
+          exclusive: self[:exclusive],
+          passive: self[:passive],
+          active: self[:active],
+          write: self[:write],
+          read: self[:read]
+        }
+      end
+      
+      def free!
+        self[:realm].free!
+      end
+      
+    end
+  end
+end

data/lib/rabbitmq/ffi/gen/access_request_ok.rb

@@ -0,0 +1,29 @@
+
+module RabbitMQ
+  module FFI
+    class AccessRequestOk < ::FFI::Struct
+      layout(:ticket, :uint16)
+      
+      def self.id
+        :access_request_ok
+      end
+      
+      def id
+        :access_request_ok
+      end
+      
+      def apply(ticket: nil)
+        self[:ticket] = Integer(ticket) if ticket
+        self
+      end
+      
+      def to_h(free=false)
+        {ticket: self[:ticket]}
+      end
+      
+      def free!
+      end
+      
+    end
+  end
+end

data/lib/rabbitmq/ffi/gen/basic_ack.rb

@@ -0,0 +1,36 @@
+
+module RabbitMQ
+  module FFI
+    class BasicAck < ::FFI::Struct
+      layout(
+        :delivery_tag, :uint64,
+        :multiple, Boolean
+      )
+      
+      def self.id
+        :basic_ack
+      end
+      
+      def id
+        :basic_ack
+      end
+      
+      def apply(delivery_tag: nil, multiple: nil)
+        self[:delivery_tag] = Integer(delivery_tag) if delivery_tag
+        self[:multiple] = multiple unless multiple.nil?
+        self
+      end
+      
+      def to_h(free=false)
+        {
+          delivery_tag: self[:delivery_tag],
+          multiple: self[:multiple]
+        }
+      end
+      
+      def free!
+      end
+      
+    end
+  end
+end

data/lib/rabbitmq/ffi/gen/basic_cancel.rb

@@ -0,0 +1,37 @@
+
+module RabbitMQ
+  module FFI
+    class BasicCancel < ::FFI::Struct
+      layout(
+        :consumer_tag, Bytes,
+        :nowait, Boolean
+      )
+      
+      def self.id
+        :basic_cancel
+      end
+      
+      def id
+        :basic_cancel
+      end
+      
+      def apply(consumer_tag: nil, nowait: nil)
+        self[:consumer_tag] = Bytes.from_s(consumer_tag.to_s) if consumer_tag
+        self[:nowait] = nowait unless nowait.nil?
+        self
+      end
+      
+      def to_h(free=false)
+        {
+          consumer_tag: self[:consumer_tag].to_s(free),
+          nowait: self[:nowait]
+        }
+      end
+      
+      def free!
+        self[:consumer_tag].free!
+      end
+      
+    end
+  end
+end

data/lib/rabbitmq/ffi/gen/basic_cancel_ok.rb

@@ -0,0 +1,30 @@
+
+module RabbitMQ
+  module FFI
+    class BasicCancelOk < ::FFI::Struct
+      layout(:consumer_tag, Bytes)
+      
+      def self.id
+        :basic_cancel_ok
+      end
+      
+      def id
+        :basic_cancel_ok
+      end
+      
+      def apply(consumer_tag: nil)
+        self[:consumer_tag] = Bytes.from_s(consumer_tag.to_s) if consumer_tag
+        self
+      end
+      
+      def to_h(free=false)
+        {consumer_tag: self[:consumer_tag].to_s(free)}
+      end
+      
+      def free!
+        self[:consumer_tag].free!
+      end
+      
+    end
+  end
+end

data/lib/rabbitmq/ffi/gen/basic_consume.rb

@@ -0,0 +1,57 @@
+
+module RabbitMQ
+  module FFI
+    class BasicConsume < ::FFI::Struct
+      layout(
+        :ticket, :uint16,
+        :queue, Bytes,
+        :consumer_tag, Bytes,
+        :no_local, Boolean,
+        :no_ack, Boolean,
+        :exclusive, Boolean,
+        :nowait, Boolean,
+        :arguments, Table
+      )
+      
+      def self.id
+        :basic_consume
+      end
+      
+      def id
+        :basic_consume
+      end
+      
+      def apply(ticket: nil, queue: nil, consumer_tag: nil, no_local: nil, no_ack: nil, exclusive: nil, nowait: nil, arguments: nil)
+        self[:ticket] = Integer(ticket) if ticket
+        self[:queue] = Bytes.from_s(queue.to_s) if queue
+        self[:consumer_tag] = Bytes.from_s(consumer_tag.to_s) if consumer_tag
+        self[:no_local] = no_local unless no_local.nil?
+        self[:no_ack] = no_ack unless no_ack.nil?
+        self[:exclusive] = exclusive unless exclusive.nil?
+        self[:nowait] = nowait unless nowait.nil?
+        self[:arguments] = Table.from(arguments) if arguments
+        self
+      end
+      
+      def to_h(free=false)
+        {
+          ticket: self[:ticket],
+          queue: self[:queue].to_s(free),
+          consumer_tag: self[:consumer_tag].to_s(free),
+          no_local: self[:no_local],
+          no_ack: self[:no_ack],
+          exclusive: self[:exclusive],
+          nowait: self[:nowait],
+          arguments: self[:arguments].to_h(free)
+        }
+      end
+      
+      def free!
+        self[:queue].free!
+        self[:consumer_tag].free!
+        self[:arguments].free!
+      end
+      
+    end
+  end
+end