ipc_transit 0.0.1

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/t*.rb']
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/bin/trlist

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+require 'ipc_transit'
+
+
+IPCTransit.all_queues.each_pair do |qname, info|
+    puts "#{qname} = #{info['count']}"
+end
+
+#{"tqueue"=>{"qid"=>3, "count"=>0}, "test_qname"=>{"qid"=>2, "count"=>0}}
+#

data/bin/trrecv

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+require 'ipc_transit'
+require 'json'
+
+qname = ARGV[0]
+nowait = ARGV[1]
+
+
+#puts qname
+#puts message
+
+while ret = IPCTransit.receive('qname' => qname, 'nowait' => 1)
+    puts ret
+end
+

data/bin/trsend

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+require 'ipc_transit'
+require 'json'
+
+qname = ARGV[0]
+message = JSON.parse(ARGV[1])
+
+
+ret = IPCTransit.send('message' => message, 'qname' => qname)
+puts ret

data/lib/ipc_transit.rb

@@ -0,0 +1,253 @@
+require 'json'
+require 'SysVIPC'
+include SysVIPC
+
+##
+# Fast, serverless message queueing
+#
+# Author::    Dana M. Diederich (diederich@gmail.com)
+# Copyright:: Copyright (c) 2012 Dana M. Diederich
+# License::   Distributes under the same terms as Ruby
+
+class IPCTransit
+    @@queues = {}
+
+    @@ipc_transit_wire_header_args = {
+        'e' => {
+            'json' => 1,
+            'yaml' => 1,
+        },
+        'c' => {
+            'zlib' => 1,
+            'snappy' => 1,
+            'none' => 1,
+        },
+    }
+    @@ipc_transit_std_args = {
+        'message' => 1,
+        'qname' => 1,
+        'nowait' => 1,
+    }
+
+
+    ##
+    #  Send message to a queue
+    #
+    # Arguments:
+    #  message - hash reference
+    #  qname - name of queue to send to
+    #  nowait - do not block if the queue is full (optional)
+
+    def self.send(args)
+        ret = nil
+        flags = IPC_NOWAIT
+        begin
+            key = self.get_queue_id(args)
+            mq = MessageQueue.new(key, IPC_CREAT | 0666)
+            ret = mq.snd(1, pack_message(args), flags)
+        rescue Exception => msg
+            puts "Exception: #{msg}"
+        end
+        return ret
+    end
+    ##
+    #  Receive a message from a queue
+    #
+    # Arguments:
+    #  qname - name of queue to send to
+    #  nowait - do not block if the queue is full (optional)
+    #  raw - return the full meta-data (optional)
+    #
+    #  Returns:
+    #   Normally: message
+    #   Raw: the message and its meta data
+   
+    def self.receive(args)
+        ret = nil
+        flags = 0
+        if args['nowait']
+            flags = IPC_NOWAIT
+        end
+        begin
+            key = self.get_queue_id(args)
+            mq = MessageQueue.new(key, IPC_CREAT | 0666)
+            args['serialized_wire_data'] = mq.receive(0, 10000, flags)
+            self.unpack_data(args)
+        rescue Exception => msg
+#            puts "Exception: #{msg}"
+        end
+        if args['raw']
+            ret = args;
+        else
+            ret = args['message']
+        end
+        return ret
+    end
+    def self.all_queue_info()
+        self.gather_queue_info()
+        return @@queues
+    end
+
+    def self.all_queues()
+        ret = {}
+        self.all_queue_info().each_pair do |qname,v|
+            qid = v['qid']
+            x = MessageQueue.new(qid, IPC_CREAT | 0666)
+            y = x.ipc_stat
+            ct = y.msg_qnum
+            ret[qname] = {
+                'qid' => qid,
+                'count' => ct,
+            }
+        end
+        return ret
+    end
+
+    private
+    def self.get_next_id
+        new_id = 1
+        @@queues.each_pair do |k,v|
+            if v['qid'] > new_id
+                new_id = v['qid']
+            end
+        end
+        return new_id + 1
+    end
+    def self.get_queue_id(args)
+        qname = args['qname']
+        self.mk_queue_dir()
+        if @@queues[qname]
+            return @@queues[qname]['qid']
+        end
+        self.gather_queue_info()
+        if @@queues[qname]
+            return @@queues[qname]['qid']
+        end
+        begin
+            self.lock_dir()
+            file = File.open("/tmp/transit/#{qname}", 'w')
+            new_qid = get_next_id
+            file.puts("qid=#{new_qid}")
+            file.puts("qname=#{qname}")
+            file.close
+            rescue Exception => msg
+                self.unlock_dir()
+            raise msg
+        end
+        self.unlock_dir()
+        self.gather_queue_info()
+        return @@queues[qname]['qid']
+    end
+
+    def self.lock_dir()
+        File.open('/tmp/transit.lock', File::WRONLY|File::EXCL|File::CREAT, 0666)
+    end
+    def self.unlock_dir()
+        File.delete('/tmp/transit.lock')
+    end
+
+    def self.gather_queue_info()
+        self.mk_queue_dir()
+        Dir.glob('/tmp/transit/*').each do |filename|
+            info = {}
+            file = File.new(filename, 'r')
+            while (line = file.gets)
+                line.chomp!
+                (key, value) = line.split('=')
+                info[key] = value
+            end
+            if not info['qid']
+                raise "required key 'qid' not found"
+            end
+            if not info['qname']
+                raise "required key 'qname' not found"
+            end
+            info['qid'] = Integer(info['qid'])
+            @@queues[info['qname']] = info
+        end
+    end
+
+    def self.mk_queue_dir()
+        begin
+            Dir.mkdir('/tmp/transit', 0777)
+        rescue
+        end
+    end
+
+
+    def self.transit_freeze(args)
+        return args['message'].to_json
+    end
+
+    def self.transit_thaw(args)
+        return JSON.parse(args['serialized_message'])
+    end
+
+
+
+#returns a scalar, ready to be sent on the wire
+#it takes message and wire_meta_data
+    def self.pack_message(args)
+        args['message']['.ipc_transit_meta'] = {}
+        args.keys.each do |k|
+            next if @@ipc_transit_wire_header_args[k]
+            next if @@ipc_transit_std_args[k]
+            args['message']['.ipc_transit_meta'][k] = args[k]
+        end
+        args['serialized_message'] = self.transit_freeze(args)
+        self.serialize_wire_meta(args)
+        l = args['serialized_wire_meta_data'].length
+        ret = "#{l}:#{args['serialized_wire_meta_data']}#{args['serialized_message']}"
+        return ret
+    end
+
+    def self.serialize_wire_meta(args)
+        s = ''
+        args.keys.each do |k|
+            if @@ipc_transit_wire_header_args[k]
+                #make sure a valid value is passed in
+                if @@ipc_transit_wire_header_args[k] == 1
+                    s = "#{s}#{k}=#{args[k]},"
+                elsif @@ipc_transit_wire_header_args[k][args[k]]
+                    s = "#{s}#{k}=#{args[k]},"
+                else
+                    raise "passed wire argument #{k} had value #{args[k]} not of allowed type"
+                end
+            end
+        end
+        if s
+            s = s[0..-2]  #teh google says this is the way to remove last character
+        end
+        args['serialized_wire_meta_data'] = s
+    end
+
+#NB: I know this is all hideously inefficient.  I'm still learning Ruby,
+#and I'm focusing on getting this correct first.
+#
+#returns a serialized_message and wire_meta_data
+#takes serialized_wire_data
+    def self.unpack_data(args)
+        stuff = args['serialized_wire_data'].split(':')
+        offset = Integer(stuff.shift)
+        header_and_message = stuff.join(':')
+        if offset == 0
+            args['serialized_header'] = ''
+        else
+            args['serialized_header'] = header_and_message[0..offset-1]
+            self.thaw_wire_headers(args)
+        end
+        args['serialized_message'] = header_and_message[offset..header_and_message.length]
+        args['message'] = self.transit_thaw(args)
+        return true
+    end
+
+    def self.thaw_wire_headers(args)
+        h = args['serialized_header']
+        ret = {}
+        h.split(',').each do |val|
+            (k,v) = val.split('=')
+            ret[k] = v
+        end
+        args['wire_headers'] = ret
+    end
+end

data/test/tc_transit_simple.rb

@@ -0,0 +1,76 @@
+require 'test/unit'
+require 'ipc_transit'
+
+#kind of ghetto, but I don't have a better way right now
+def drain_test_queue
+    begin
+        while ret = IPCTransit.receive('qname' => 'test_qname', 'nowait' => 1)
+        end
+    rescue Exception => msg
+    end
+end
+
+class TestIPCTransit < Test::Unit::TestCase
+    def test_typical
+        drain_test_queue()
+        IPCTransit.send('message' => { 'foo' => 'bar' }, 'qname' => 'test_qname')
+        ret = IPCTransit.receive('qname' => 'test_qname', 'nowait' => 1)
+        assert(ret, 'IPCTransit.receive returned true')
+        assert_equal(ret['foo'], 'bar')
+    end
+
+    def test_wire_raw
+        drain_test_queue()
+        IPCTransit.send('message' => { 'foo' => 'bar' }, 'qname' => 'test_qname', 'e' => 'json', 'c' => 'none')
+        ret = IPCTransit.receive('qname' => 'test_qname', 'raw' => 1, 'nowait' => 1)
+        assert(ret, 'IPCTransit.receive returned true')
+        assert_equal(ret['message']['foo'], 'bar')
+        assert_equal(ret['wire_headers']['e'], 'json')
+        assert_equal(ret['wire_headers']['c'], 'none')
+    end
+    def test_message_meta
+        drain_test_queue()
+        IPCTransit.send( 'qname' => 'test_qname',
+                'message' => { 'foo' => 'bar' },
+                'e' => 'json',
+                'c' => 'none',
+                'something' => 'else',
+                'x' => { 'this' => 'that' },
+                'once' => ['more',2],
+        )
+        ret = IPCTransit.receive('qname' => 'test_qname', 'nowait' => 1)
+        assert(ret, 'IPCTransit.receive returned true')
+        assert_equal(ret['foo'], 'bar')
+        assert_equal(ret['.ipc_transit_meta']['something'], 'else')
+        assert_equal(ret['.ipc_transit_meta']['x']['this'], 'that')
+        assert_equal(ret['.ipc_transit_meta']['once'][0], 'more')
+        assert_equal(ret['.ipc_transit_meta']['once'][1], 2)
+    end
+
+    def test_get_queue_info
+        drain_test_queue()
+        all_info = IPCTransit.all_queue_info()
+        IPCTransit.send('message' => { 'foo' => 'bar' }, 'qname' => 'test_qname')
+        assert(all_info, 'We received some queue info')
+
+        assert(all_info['test_qname']['qname'] == 'test_qname', 'test queue is in all_queue_info')
+        qid = all_info['test_qname']['qid']
+        assert(qid, 'queue_id for test_qname exists')
+
+        ret = IPCTransit.receive('qname' => 'test_qname', 'nowait' => 1)
+        assert(ret, 'IPCTransit.receive returned true')
+        assert_equal(ret['foo'], 'bar')
+    end
+
+    def test_all_queues
+        drain_test_queue()
+        IPCTransit.send('message' => { 'foo' => 'bar' }, 'qname' => 'test_qname')
+        ret = IPCTransit.all_queues()
+        assert(ret, 'IPCTransit.all_queues returned true')
+        assert(ret['test_qname']['count'] == 1, 'exactly one message in test_qname')
+        ret = IPCTransit.receive('qname' => 'test_qname', 'nowait' => 1)
+        assert(ret, 'IPCTransit.receive returned true')
+        assert_equal(ret['foo'], 'bar')
+    end
+end
+

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: ipc_transit
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Dana M. Diederich
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: SysVIPC
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Serverless Message Queue
+email: diederich@gmail.com
+executables:
+- trrecv
+- trsend
+- trlist
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- lib/ipc_transit.rb
+- bin/trrecv
+- bin/trsend
+- bin/trlist
+- test/tc_transit_simple.rb
+homepage: http://rubygems.org/gems/ipc_transit
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Serverless, cross-language, fast message queue library
+test_files:
+- test/tc_transit_simple.rb