ekaranto-rubywmq 2.0.0

data/lib/rubywmq.rb

@@ -0,0 +1 @@
+require 'wmq'

data/lib/wmq/message.rb

@@ -0,0 +1,70 @@
+# Message Ruby methods
+module WMQ
+  # Message contains the message descriptor (MQMD), data
+  # and any headers.
+  #
+  # Note:
+  # * The format in the descriptor applies only to the format of the data portion,
+  #   not the format of any included headers
+  # * The message format can ONLY be supplied in the descriptor.
+  #   * I.e. It is the format of the data, Not the headers.
+  #   * On the wire formats are determined automatically by the :header_type key for
+  #     each header
+  #   * Other WebSphere MQ interfaces require that the formats be "daisy-chained"
+  #     * I.e. The MQMD.Format is actually the format of the first header
+  #     * Ruby WMQ removes this tedious requirement and performs this
+  #       requirement automatically under the covers
+  #   * The format of any header should not be supplied in the descriptor or any header
+  #
+  # Message has the following attributes:
+  # * descriptor = {
+  #                                                           # WebSphere MQ Equivalent
+  #     :format             => WMQ::MQFMT_STRING,             # MQMD.Format - Format of data only
+  #                            WMQ::MQFMT_NONE                #   Do not supply header formats here
+  #     :original_length    => Number                         # MQMD.OriginalLength
+  #     :priority           => 0 .. 9                         # MQMD.Priority
+  #     :put_time           => String                         # MQMD.PutTime
+  #     :msg_id             => String                         ...
+  #     :expiry             => Number
+  #     :persistence        => Number
+  #     :reply_to_q         => String
+  #     :correl_id          => String
+  #     :feedback           => Number
+  #     :offset             => Number
+  #     :report             => Number
+  #     :msg_flags          => Number
+  #     :reply_to_q_mgr     => String
+  #     :appl_identity_data => String
+  #     :put_appl_name      => String
+  #     :user_identifier    => String
+  #     :msg_seq_number     => Number
+  #     :appl_origin_data   => String
+  #     :accounting_token   => String
+  #     :backout_count      => Number
+  #     :coded_char_set_id  => Number
+  #     :put_appl_type      => Number
+  #     :msg_type           => Number
+  #     :group_id           => String
+  #     :put_date           => String
+  #     :encoding           => Number
+  #   }
+  # * data => String
+  # * headers => Array of Hashes
+  #   * Note: Do not supply the format of any header. Ruby WMQ does this for you.
+  #
+  #    The following headers are supported:
+  #   * Rules And Formatting Header (RFH)
+  #       :header_type => :rf_header
+  #       :....
+  #   * Rules and Formatting V2 Header (RFH2)
+  #       ....
+  #   * Dead Letter Header
+  #   * CICS Header
+  #   * IMS Header
+  #   * Transmission Queue Header
+  #   * ...
+  class Message
+    attr_accessor :data, :descriptor, :headers
+  end
+
+end

data/lib/wmq/queue_manager.rb

@@ -0,0 +1,110 @@
+# QueueManager ruby methods
+module WMQ
+  class QueueManager
+    # Execute any MQSC command against the queue manager
+    #
+    # Example
+    #   require 'wmq/wmq'
+    #   require 'wmq/wmq_const_admin'
+    #   WMQ::QueueManager.connect(:q_mgr_name=>'REID', :connection_name=>'localhost(1414)') do |qmgr|
+    #     qmgr.mqsc('dis ql(*)').each {|item| p item }
+    #   end
+    def mqsc(mqsc_text)
+      self.execute(:command=>:escape, :escape_type=>WMQ::MQET_MQSC, :escape_text=>mqsc_text).collect {|item| item[:escape_text] }
+    end
+
+    # Put a reply message back to the sender
+    #
+    #   The :message is sent to the queue and queue manager specified in the
+    #   :reply_to_q and :reply_to_q_mgr propoerties of the :request_message.
+    #
+    #   The following rules are followed before sending the reply:
+    #   - Only send replies to Request messages. No reply for Datagrams
+    #   - Set the message type to Reply when replying to a request message
+    #   - Reply with:
+    #     - Remaining Expiry (Ideally deduct any processing time since get)
+    #     - Same priority as received message
+    #     - Same persistence as received message
+    #   - Adhere to the Report options supplied for message and correlation id's
+    #       in reply message
+    #   - All headers must be returned on reply messages
+    #     - This allows the calling application to store state information
+    #       in these headers
+    #     - Unless of course if the relevant header is input only and used
+    #       for completing the request
+    #       - In this case any remaining headers should be returned
+    #         to the caller
+    #
+    # Parameters:
+    #   * :request_message The message originally received
+    #   * All the other parameters are the same as QueueManager#put
+    #
+    def put_to_reply_q(parms)
+      # Send replies only if message type is request
+      if parms[:request_message].descriptor[:msg_type] == WMQ::MQMT_REQUEST
+        request = parms.delete(:request_message)
+
+        reply = parms[:message] ||= Message.new(:data=>parms[:data])
+        reply.descriptor[:msg_type]   = WMQ::MQMT_REPLY
+        reply.descriptor[:expiry]     = request.descriptor[:expiry]
+        reply.descriptor[:priority]   = request.descriptor[:priority]
+        reply.descriptor[:persistence]= request.descriptor[:persistence]
+        reply.descriptor[:format] = request.descriptor[:format]
+
+        # Set Correlation Id based on report options supplied
+        if request.descriptor[:report] & WMQ::MQRO_PASS_CORREL_ID != 0
+          reply.descriptor[:correl_id] = request.descriptor[:correl_id]
+        else
+          reply.descriptor[:correl_id] = request.descriptor[:msg_id]
+        end
+
+        # Set Message Id based on report options supplied
+        if request.descriptor[:report] & WMQ::MQRO_PASS_MSG_ID != 0
+          reply.descriptor[:msg_id] = request.descriptor[:msg_id]
+        end
+
+        parms[:q_name]    = request.descriptor[:reply_to_q]
+        parms[:q_mgr_name]= request.descriptor[:reply_to_q_mgr]
+        return put(parms)
+      else
+        return false
+      end
+    end
+
+    # Put a message to the Dead Letter Queue
+    #
+    #   If an error occurs when processing a datagram message
+    #   it is necessary to move the message to the dead letter queue.
+    #   I.e. An error message cannot be sent back to the sender because
+    #        the original message was not a request message.
+    #          I.e. msg_type != WMQ::MQMT_REQUEST
+    #
+    #   All existing message data, message descriptor and message headers
+    #   are retained.
+    #
+    def put_to_dead_letter_q(parms)
+      message = parms[:message] ||= Message.new(:data=>parms[:data])
+      dlh = {
+        :header_type     =>:dead_letter_header,
+        :reason          =>parms.delete(:reason),
+        :dest_q_name     =>parms.delete(:q_name),
+        :dest_q_mgr_name =>self.name}
+
+      message.headers.unshift(dlh)
+      parms[:q_name]='SYSTEM.DEAD.LETTER.QUEUE'  #TODO Should be obtained from QMGR config
+      return self.put(parms)
+    end
+
+    # Expose Commands directly as Queue Manager methods
+    def method_missing(name, *args)
+      if args.size == 1
+        self.execute({:command=>name}.merge(args[0]))
+      elsif args.size == 0
+        self.execute({:command=>name})
+      else
+        raise("Invalid arguments supplied to QueueManager#:#{name}, args:#{args}")
+      end
+    end
+
+  end
+end

data/lib/wmq/version.rb

@@ -0,0 +1,3 @@
+module WMQ #:nodoc
+  VERSION = "2.0.0"
+end

data/lib/wmq.rb

@@ -0,0 +1,16 @@
+require 'wmq/version'
+require 'wmq/constants'
+require 'wmq/constants_admin'
+require 'wmq/queue_manager'
+require 'wmq/message'
+
+# Load wmq using the auto-load library.
+#
+# If it fails, then it is most likely since this platform is not supported
+# by the auto load facility in Ruby WMQ, so try to load client linked library
+# For Example AIX does not support Autoload whereas Windows and Linux are supported
+begin
+  require 'wmq/wmq'
+rescue LoadError
+  require 'wmq/wmq_client'
+end

data/nbproject/project.properties

@@ -0,0 +1,11 @@
+examples.dir=${file.reference.trunk-examples}
+file.reference.trunk-examples=examples
+file.reference.trunk-ext=ext
+file.reference.trunk-lib=lib
+file.reference.trunk-tests=tests
+javac.classpath=
+lib.dir=${file.reference.trunk-lib}
+main.file=
+source.encoding=UTF-8
+src.dir=${file.reference.trunk-ext}
+test.src.dir=${file.reference.trunk-tests}

data/nbproject/project.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://www.netbeans.org/ns/project/1">
+    <type>org.netbeans.modules.ruby.rubyproject</type>
+    <configuration>
+        <data xmlns="http://www.netbeans.org/ns/ruby-project/1">
+            <name>rubywmq</name>
+            <source-roots>
+                <root id="src.dir" name="ext"/>
+                <root id="examples.dir"/>
+                <root id="lib.dir" name="Source Files"/>
+            </source-roots>
+            <test-roots>
+                <root id="test.src.dir"/>
+            </test-roots>
+        </data>
+    </configuration>
+</project>

data/tests/test.rb

@@ -0,0 +1,318 @@
+# Allow test to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'rubygems'
+require 'wmq'
+require 'test/unit'
+class TestTest < Test::Unit::TestCase
+
+  def setup
+    puts '****** setup: start ******'
+    @queue_manager = WMQ::QueueManager.new(:q_mgr_name => 'TEST') #, :connection_name=>'localhost(1414)')
+    @queue_manager.connect
+
+    # Create Queue and clear any messages from the queue
+    @in_queue = WMQ::Queue.new(:queue_manager=>@queue_manager,
+                               :mode=>:input,
+                               :dynamic_q_name=>'UNIT.TEST.*',
+                               :q_name=>'SYSTEM.DEFAULT.MODEL.QUEUE',
+                               :fail_if_exists=>false)
+    @in_queue.open
+    @in_queue.each { |message| }
+
+    # Open same queue for Output. Queue should be created by now
+    @out_queue = WMQ::Queue.new(:queue_manager=>@queue_manager,
+                                :mode=>:output,
+                                :q_name=>@in_queue.name)
+    @out_queue.open
+    puts '****** setup: end ******'
+  end
+
+  def teardown
+    puts '****** teardown: start ******'
+    @out_queue.close
+    @in_queue.close
+    @queue_manager.disconnect
+    puts '****** teardown: end ******'
+  end
+
+  def test_exceptions
+    puts '****** test_exceptions: start ******'
+    assert_raise(TypeError) { WMQ::QueueManager.new(1) }
+    assert_nothing_raised   { WMQ::QueueManager.new(:exception_on_error=>nil) }
+    assert_raise(TypeError) { WMQ::QueueManager.new(:exception_on_error=>1) }
+    assert_raise(TypeError) { WMQ::QueueManager.new(:q_mgr_name=>2).connect }
+    assert_raise(WMQ::WMQException) { WMQ::QueueManager.new(:q_mgr_name=>'bad').connect }
+    puts '****** test_exceptions: end ******'
+  end
+
+  def test_queue_manager
+    puts '****** test_queue_manager ******'
+    assert_equal(Object, WMQ::QueueManager.superclass)
+    assert_equal(WMQ::QueueManager, @queue_manager.class)
+  end
+
+  def test_1
+    puts '****** test_1 ******'
+    assert_equal(@out_queue.put(:data=>'Hello World'), true)
+    message = WMQ::Message.new
+    assert_equal(@in_queue.get(:message=>message), true)
+    assert_equal(message.data, 'Hello World')
+  end
+
+  def test_dynamic_buffer
+    puts '****** test_dynamic_buffer ******'
+    # Clear out queue of any messages
+    @in_queue.each { |message| }
+
+    test_sizes = [0, 1, 100, 101, 102, 500, 65534, 65535, 65536, 65537, 1*1024*1024, 4*1024*1024]
+    test_sizes.each do |size|
+      str = '0123456789ABCDEF' * (size/16) + '0123456789ABCDEF'[0,size%16]
+      assert_equal(str.length, size)
+      assert_equal(@out_queue.put(:data=>str), true)
+    end
+
+    # First test the browse mechanism
+    counter = 0
+    @queue_manager.open_queue(:mode=>:browse, :q_name=>@in_queue.name) do |browse_queue|
+      browse_queue.each do |message|
+        size = test_sizes[counter]
+        assert_equal(size, message.data.length)
+        str = '0123456789ABCDEF' * (size/16) + '0123456789ABCDEF'[0,size%16]
+        assert_equal(str, message.data)
+        counter = counter + 1
+      end
+    end
+    assert_equal(test_sizes.size, counter)
+
+    # Now retrieve the messages destructively
+    message = WMQ::Message.new
+    test_sizes.each do |size|
+      assert_equal(true, @in_queue.get(:message=>message, :match=>WMQ::MQMO_NONE))
+      assert_equal(size, message.data.length)
+      str = '0123456789ABCDEF' * (size/16) + '0123456789ABCDEF'[0,size%16]
+      assert_equal(str, message.data)
+    end
+  end
+
+  def test_q_name_hash
+    puts '****** test_q_name_hash ******'
+    @queue_manager.open_queue(:mode=>:output,
+                              :q_name=>{:q_name=>@in_queue.name,
+                                        :q_mgr_name=>@queue_manager.name}
+                             ) do |test_queue|
+      assert_equal(true, test_queue.put(:data=>'Hello World'))
+      message = WMQ::Message.new
+      assert_equal(true, @in_queue.get(:message=>message))
+      assert_equal('Hello World', message.data)
+    end
+  end
+
+  def test_execute
+    puts '****** test_execute ******'
+    array = @queue_manager.inquire_q(:q_name=>@in_queue.name, :q_type=>WMQ::MQQT_LOCAL, :current_q_depth=>nil)
+    assert_equal(1, array.size)
+    assert_equal(@in_queue.name, array[0][:q_name])
+
+    assert_equal(true, @queue_manager.inquire_process(:process_name=>'*').size>0)
+    assert_raise(WMQ::WMQException) { @queue_manager.inquire_q(:q_name=>'BADQUEUENAME*') }
+    assert_equal(1, @queue_manager.ping_q_mgr.size)
+  end
+
+  def test_mqsc
+    puts '****** test_mqsc ******'
+    array = @queue_manager.mqsc("dis ql(#{@in_queue.name})")
+    assert_equal(1, array.size)
+    assert_equal(true, array[0].include?("QUEUE(#{@in_queue.name})"))
+  end
+
+  def test_put1
+    puts '****** test_put1 ******'
+    data = 'Some Test Data'
+    assert_equal(true,@queue_manager.put(:q_name=>@in_queue.name, :data=>data))
+
+    message = WMQ::Message.new
+    assert_equal(true, @in_queue.get(:message=>message))
+    assert_equal(data, message.data)
+  end
+
+  def verify_header(header, format)
+    verify_multiple_headers([header], format)
+  end
+
+  def verify_multiple_headers(headers, format)
+    data = 'Some Test Data'
+    message = WMQ::Message.new
+    message.data = data
+    message.descriptor[:format] = format
+    message.headers = headers
+    #assert_equal(true,@queue_manager.put(:q_name=>@in_queue.name, :message=>message))
+    assert_equal(true,@out_queue.put(:message=>message))
+
+    message = WMQ::Message.new
+    assert_equal(true, @in_queue.get(:message=>message))
+    assert_equal(data, message.data)
+    assert_equal(headers.size, message.headers.size)
+    count = 0
+    headers.each do |header|
+      reply_header = message.headers[count]
+      header.each_pair{|key, value| assert_equal(value, reply_header[key])}
+      count = count + 1
+    end
+  end
+
+  def test_dlh
+    puts '****** test_dlh ******'
+    dlh = {:header_type     =>:dead_letter_header,
+           :reason          => WMQ::MQRC_UNKNOWN_REMOTE_Q_MGR,
+           :dest_q_name     =>'ORIGINAL_QUEUE_NAME',
+           :dest_q_mgr_name =>'BAD_Q_MGR',
+           :put_appl_name   =>'TestApp.exe',
+           }
+
+    verify_header(dlh, WMQ::MQFMT_DEAD_LETTER_HEADER)
+    # Untested keys:
+    #:put_date=>"",
+    #:put_time=>"",
+    #:encoding=>0,
+    #:coded_char_set_id=>437,
+    #:put_appl_type=>0,
+
+    # Test again, but use QueueManager#put this time
+    data = 'Some Test Data'
+    message = WMQ::Message.new
+    message.data = data
+    message.descriptor[:format] = WMQ::MQFMT_STRING
+    message.headers << dlh
+    assert_equal(true,@queue_manager.put(:q_name=>@in_queue.name, :message=>message))
+
+    message = WMQ::Message.new
+    assert_equal(true, @in_queue.get(:message=>message))
+    assert_equal(data, message.data)
+    assert_equal(1, message.headers.size)
+    reply_header = message.headers[0]
+
+    dlh.each_pair{|key, value| assert_equal(value, reply_header[key])}
+  end
+
+  def test_cics
+    puts '****** test_cics ******'
+    cics = {:header_type     =>:cics,
+            :reason          =>WMQ::MQRC_UNKNOWN_REMOTE_Q_MGR,
+            :facility        =>'TOKEN123',
+            :reply_to_format =>WMQ::MQFMT_STRING,
+            }
+    verify_header(cics, WMQ::MQFMT_NONE)
+  end
+
+  def test_ims
+    puts '****** test_ims ******'
+    ims = {:header_type      =>:ims,
+           :l_term_override  =>'LTERM',
+           :reply_to_format  =>WMQ::MQFMT_STRING,
+          }
+    verify_header(ims, WMQ::MQFMT_STRING)
+  end
+
+  def test_transmission_header
+    puts '****** test_transmission_header ******'
+    xqh = {:header_type     =>:xmit_q_header,
+           :remote_q_name   =>'SOME_REMOTE_QUEUE',
+           :remote_q_mgr_name=>'SOME_REMOTE_Q_MGR',
+           :msg_type        =>WMQ::MQMT_REQUEST,
+           :msg_id          =>'my message Id',
+          }
+    verify_header(xqh, WMQ::MQFMT_STRING)
+  end
+
+  def test_rf_header
+    puts '****** test_rf_header ******'
+    rfh = {:header_type =>:rf_header,
+           :name_value  => {' name   s' => '  v a "l" u e 1  ',
+                            'n a m e 2 ' => 'v a l u e  2',
+                            '' => ['"', '""', '"""', '""""', ''],
+                            'name3'=>['"value3"', '', '"',' value 43"']},
+          }
+    verify_header(rfh, WMQ::MQFMT_STRING)
+  end
+
+  def test_rf_header_2
+    puts '****** test_rf_header_2 ******'
+    rfh2 = {:header_type =>:rf_header_2,
+            :xml => ['<hello>to the world</hello>',
+                     '<another>xml like string</another>'],
+           }
+    verify_header(rfh2, WMQ::MQFMT_STRING)
+  end
+
+  def test_multiple_headers
+    puts '****** test_multiple_headers ******'
+    headers = [{:header_type      => :rf_header_2,
+                :xml              => ['<hello>to the world</hello>',
+                                      '<another>xml like string</another>'],},
+
+               {:header_type      => :rf_header,
+                :name_value       => {' name   s' => '  v a l u e 1  ',
+                                      'n a m e 2 ' => 'v a l u e  2',
+                                      'name3'=>['value3', '', 'value 43']} },
+
+               {:header_type      => :ims,
+                :l_term_override  => 'LTERM',
+                :reply_to_format  => WMQ::MQFMT_STRING},
+
+               {:header_type      => :rf_header,
+                :name_value       => {' name   s' => '  v a l u e 1  ',
+                                      'n a m e 2 ' => 'v a l u e  2',
+                                      'name3'=>['value3', '', 'value 43']} },
+
+               {:header_type      => :cics,
+                :reason           => WMQ::MQRC_UNKNOWN_REMOTE_Q_MGR,
+                :facility         => 'TOKEN123',
+                :reply_to_format  => WMQ::MQFMT_STRING},
+
+               {:header_type      => :rf_header_2,
+                :xml              => ['<hello>to the world</hello>', '<another>xml like string</another>'],},
+
+               {:header_type      => :xmit_q_header,
+                :remote_q_name    => 'SOME_REMOTE_QUEUE',
+                :remote_q_mgr_name=> 'SOME_REMOTE_Q_MGR',
+                :msg_type         => WMQ::MQMT_REQUEST,
+                :msg_id           => 'my message Id'},
+              ]
+    verify_multiple_headers(headers, WMQ::MQFMT_STRING)
+  end
+
+  def test_xmit_multiple_headers
+    puts '****** test_xmit_q_header with ims header ******'
+    headers = [{:header_type      => :xmit_q_header,
+                :remote_q_name    => 'SOME_REMOTE_QUEUE',
+                :remote_q_mgr_name=> 'SOME_REMOTE_Q_MGR',
+                :msg_type         => WMQ::MQMT_REQUEST,
+                :msg_id           => 'my message Id'},
+
+               {:header_type      => :ims,
+                :l_term_override  => 'LTERM',
+                :reply_to_format  => WMQ::MQFMT_STRING},
+              ]
+    verify_multiple_headers(headers, WMQ::MQFMT_STRING)
+  end
+
+  def test_message_grouping
+    puts '****** test_message_grouping ******'
+    # Clear out queue of any messages
+    @in_queue.each { |message| }
+
+    msg = WMQ::Message.new
+    msg.data = 'First'
+    msg.descriptor[:msg_flags] = WMQ::MQMF_MSG_IN_GROUP
+    assert_equal(@out_queue.put(:message=>msg, :options => WMQ::MQPMO_LOGICAL_ORDER), true)
+
+    msg.data = 'Second'
+    assert_equal(@out_queue.put(:message=>msg, :options => WMQ::MQPMO_LOGICAL_ORDER), true)
+
+    msg.data = 'Last'
+    msg.descriptor[:msg_flags] = WMQ::MQMF_LAST_MSG_IN_GROUP
+    assert_equal(@out_queue.put(:message=>msg, :options => WMQ::MQPMO_LOGICAL_ORDER), true)
+  end
+
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: ekaranto-rubywmq
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Reid Morrison
+- Edwin Fine
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: RubyWMQ is a high performance native Ruby interface into WebSphere MQ.
+email:
+- reidmo@gmail.com
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/each_a.rb
+- examples/each_b.rb
+- examples/each_header.rb
+- examples/files_to_q.cfg
+- examples/files_to_q.rb
+- examples/get_a.rb
+- examples/get_client.rb
+- examples/put1_a.rb
+- examples/put1_b.rb
+- examples/put1_c.rb
+- examples/put_a.rb
+- examples/put_b.rb
+- examples/put_dlh.rb
+- examples/put_dynamic_q.rb
+- examples/put_group_a.rb
+- examples/put_group_b.rb
+- examples/put_rfh.rb
+- examples/put_rfh2_a.rb
+- examples/put_rfh2_b.rb
+- examples/put_xmit_q.rb
+- examples/q_to_files.cfg
+- examples/q_to_files.rb
+- examples/request.rb
+- examples/server.rb
+- ext/decode_rfh.c
+- ext/decode_rfh.h
+- ext/extconf.rb
+- ext/extconf_client.rb
+- ext/generate/generate_const.rb
+- ext/generate/generate_reason.rb
+- ext/generate/generate_structs.rb
+- ext/generate/wmq_structs.erb
+- ext/wmq.c
+- ext/wmq.h
+- ext/wmq_message.c
+- ext/wmq_mq_load.c
+- ext/wmq_queue.c
+- ext/wmq_queue_manager.c
+- lib/rubywmq.rb
+- lib/wmq.rb
+- lib/wmq/message.rb
+- lib/wmq/queue_manager.rb
+- lib/wmq/version.rb
+- nbproject/project.properties
+- nbproject/project.xml
+- tests/test.rb
+- .document
+homepage: https://github.com/reidmorrison/rubywmq
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.4
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- WebSphere MQ v5.3, v6 or v7 Client or Server with Development Kit
+rubyforge_project: rubywmq
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Native Ruby interface into WebSphere MQ
+test_files:
+- tests/test.rb