rmq 0.0.7 → 0.0.8

data/lib/rmq/exceptions.rb

@@ -18,4 +18,13 @@ module RMQ
   class RMQTimeOutError < RuntimeError
   end
 
+  class RMQMessageNotFoundException < RuntimeError
+    def initialize(message_id)
+    end
+
+    def message
+      "Could not find message"
+    end
+  end
+
 end

data/lib/rmq/message.rb

@@ -10,5 +10,10 @@ module RMQ
     def reply_queue_name
       @message_descriptor[:ReplyToQ].to_s.strip
     end
+
+    def message_id
+      @message_descriptor[:MsgId]
+    end
+
   end
 end

data/lib/rmq/message_descriptor.rb

@@ -22,7 +22,7 @@ module RMQ
         :Format, [:char, 8],
         :Priority, :long,
         :Persistence, :long,
-        :MsgId, [:char, MSG_ID_LENGTH],
+        :MsgId, [:uint8, MSG_ID_LENGTH],
         :CorrelId, [:char, 24],
         :BackoutCount, :long,
         :ReplyToQ, [:char, 48],

data/lib/rmq/mqclient.rb

@@ -1,14 +1,16 @@
+require 'rbconfig'
+
 module RMQ
   module MQClient
     include Constants
     extend FFI::Library
 
     def MQClient.running_on_windows?
-      (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM) != nil
+      (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RbConfig::CONFIG['host_os']) != nil
     end
 
     def MQClient.running_on_linux?
-      RUBY_PLATFORM.include?("linux")
+      RbConfig::CONFIG['host_os'].include?("linux")
     end
 
     ffi_lib "mqic32.dll" if running_on_windows?
@@ -239,6 +241,8 @@ module RMQ
 
       mqput(connection_handle, queue_handle, message_descriptor, message_options, payload.length, payload, completion_code_ptr, reason_code_ptr)
       raise RMQException.new(completion_code_ptr.read_long, reason_code_ptr.read_long), "Cannot send message" if completion_code_ptr.read_long != MQCC_OK
+
+      message_descriptor[:MsgId]
     end
 
     def queue_depth(connection_handle, queue_name)
@@ -260,14 +264,13 @@ module RMQ
       queue_depth
     end
 
-    def get_message_from_queue(connection_handle, queue_handle, timeout)
-      puts "--- get message from queue"
+    def get_message_from_queue(connection_handle, queue_handle, options = {})
       completion_code_ptr = FFI::MemoryPointer.new :long
       reason_code_ptr = FFI::MemoryPointer.new :long
       data_length_ptr = FFI::MemoryPointer.new :long
 
-      message_options = prepare_get_message_options(timeout, false)
-      message_descriptor = prepare_get_message_descriptor
+      message_options = prepare_get_message_options(false, options)
+      message_descriptor = prepare_get_message_descriptor(options)
 
       data_length = 8 * 1024
       buffer_ptr = FFI::MemoryPointer.new :char, data_length
@@ -285,12 +288,21 @@ module RMQ
         raise RMQException.new(completion_code_ptr.read_long, reason_code_ptr.read_long), "Cannot learn message length" unless completion_code_ptr.read_long == MQCC_OK
       end
 
-      Message.new(buffer_ptr.read_string, message_descriptor)
+      RMQ::Message.new(buffer_ptr.read_string, message_descriptor)
+    end
+
+    def print_msg_id(msg_id)
+      hex_string = ''
+      for i in (0..MQClient::MessageDescriptor::MSG_ID_LENGTH-1) do
+        hex_string << "0x#{msg_id[i].to_s(16)}"
+        hex_string << ", " if i < MQClient::MessageDescriptor::MSG_ID_LENGTH-1
+      end
+      hex_string
     end
 
     private
 
-    def prepare_get_message_options(timeout, accept_truncated_msg)
+    def prepare_get_message_options(accept_truncated_msg, options = {})
       message_options = GetMessageOptions.new
       message_options[:StrucId] = GetMessageOptions::MQGMO_STRUC_ID
       message_options[:Version] = GetMessageOptions::MQGMO_VERSION_1
@@ -300,29 +312,23 @@ module RMQ
         message_options[:Options] = GetMessageOptions::MQGMO_ACCEPT_TRUNCATED_MSG | message_options[:Options]
       end
 
-      if timeout > 0
+      if options.has_key?(:timeout)
         message_options[:Options] = GetMessageOptions::MQGMO_WAIT | message_options[:Options]
-        message_options[:WaitInterval] = timeout * 1000
+        message_options[:WaitInterval] = options[:timeout] * 1000
       end
 
       message_options
     end
 
-    def print_msg_id(msg_id)
-      puts "printing msg id"
-      for i in (0..MQClient::MessageDescriptor::MSG_ID_LENGTH-1) do
-        puts "#{i} = #{msg_id[i]}"
-      end
-    end
-
-    def prepare_get_message_descriptor(msg_id = nil)
+    def prepare_get_message_descriptor(options)
       message_descriptor = MQClient::MessageDescriptor.new
       message_descriptor[:StrucId] = MQClient::MessageDescriptor::MQMD_STRUC_ID
       message_descriptor[:Version] = MQClient::MessageDescriptor::MQMD_VERSION_1
 
-      if !msg_id.nil?
+      if options.has_key?(:message_id)
+        msg_id = options[:message_id]
         for i in (0..MQClient::MessageDescriptor::MSG_ID_LENGTH-1) do
-          message_descriptor[:MsgId][i] = msg_id[i]
+          message_descriptor[:MsgId][i] = msg_id[i].nil? ? 0 : msg_id[i]
         end
       end
 

data/lib/rmq/queue.rb

@@ -13,10 +13,12 @@ module RMQ
     def put_message(payload, reply_queue_name = "")
       @queue_handle = open_queue(@queue_manager.connection_handle, @queue_name, Constants::MQOO_OUTPUT) if @queue_handle.nil?
 
-      put_message_on_queue(@queue_manager.connection_handle, @queue_handle, payload, reply_queue_name)
+      message_id = put_message_on_queue(@queue_manager.connection_handle, @queue_handle, payload, reply_queue_name)
 
       close_queue(@queue_manager.connection_handle, @queue_handle, Constants::MQCO_NONE)
       @queue_handle = nil
+
+      message_id
     end
 
     def depth
@@ -24,32 +26,48 @@ module RMQ
     end
 
     # Gets a message from the queue. A timeout period can be specified in seconds.
-    def get_message(timeout = 0)
+    def get_message(options = {})
       @queue_handle = open_queue(@queue_manager.connection_handle, @queue_name, Constants::MQOO_INPUT_SHARED) if @queue_handle.nil?
 
-      if (timeout > 0)
+      begin
         begin_time = Time.now.to_i
-        begin
-          message = get_message_from_queue(@queue_manager.connection_handle, @queue_handle, timeout)
-        rescue RMQException
-          end_time = Time.now.to_i
-          raise RMQTimeOutError.new if end_time - begin_time >= timeout
-        end
-      else
-        message = get_message_from_queue(@queue_manager.connection_handle, @queue_handle, 0)
-      end
+        message = get_message_from_queue(@queue_manager.connection_handle, @queue_handle, options)
+      rescue RMQException
+        end_time = Time.now.to_i
 
-      close_queue(@queue_manager.connection_handle, @queue_handle, Constants::MQCO_NONE)
-      @queue_handle = nil
+        raise RMQTimeOutError.new if options.has_key?(:timeout) && (end_time - begin_time >= options[:timeout])
+      ensure
+        close_queue(@queue_manager.connection_handle, @queue_handle, Constants::MQCO_NONE)
+        @queue_handle = nil
+      end
 
       message
     end
 
     # Gets a message from the queue and returns the payload only. A timeout period can be specified
     # in seconds.
-    def get_message_payload(timeout = 0)
-      message = get_message(timeout)
+    def get_message_payload(options = {})
+      message = get_message(options)
       message.payload
     end
+
+    def find_message_by_id(message_id, options = {})
+      message = get_message(options.merge({:message_id => message_id}))
+
+      if (message && compare_message_id(message_id, message.message_id))
+        return message
+      else
+        raise RMQMessageNotFoundException.new(message_id)
+      end
+    end
+
+    private
+
+    def compare_message_id(id1, id2)
+      for i in (0..MQClient::MessageDescriptor::MSG_ID_LENGTH-1) do
+        return false unless id1[i] == id2[i]
+      end
+      true
+    end
   end
 end

data/lib/rmq/version.rb

@@ -1,3 +1,3 @@
 module RMQ
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end

data/spec/rmq/queue_spec.rb

@@ -37,11 +37,28 @@ describe RMQ::Queue do
   end
 
   it "should time out waiting for a message" do
-    lambda { @queue.get_message(2) }.should raise_error(RMQ::RMQTimeOutError)
+    lambda { @queue.get_message({:timeout => 2}) }.should raise_error(RMQ::RMQTimeOutError)
   end
 
   it "should time out waiting for a message and not return any payload" do
-    lambda { @queue.get_message_payload(2) }.should raise_error(RMQ::RMQTimeOutError)
+    lambda { @queue.get_message_payload({:timeout => 2}) }.should raise_error(RMQ::RMQTimeOutError)
+  end
+
+  it "should find a message by id" do
+    message_id = @queue.put_message("I want to read this back")
+    message_id.should_not be_nil
+
+    message = @queue.find_message_by_id(message_id)
+    message.payload.should == "I want to read this back"
+  end
+
+  it "should find not a message by id" do
+    lambda { @queue.find_message_by_id([1,2,3]) }.should raise_error(RMQ::RMQMessageNotFoundException)
+  end
+
+  it "should time out when finding a message by id" do
+    message_id = [1,2,3]
+    lambda { @queue.find_message_by_id(message_id, {:timeout => 2}) }.should raise_error(RMQ::RMQTimeOutError)
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rmq
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70046720 !ruby/object:Gem::Requirement
+  requirement: &83963930 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '2.7'
   type: :development
   prerelease: false
-  version_requirements: *70046720
+  version_requirements: *83963930
 - !ruby/object:Gem::Dependency
   name: ffi
-  requirement: &70045870 !ruby/object:Gem::Requirement
+  requirement: &83963600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70045870
+  version_requirements: *83963600
 description: Ruby wrapper around MQ series client library
 email: sns@caimito.net
 executables: []