simrpc 0.2 → 0.4

data/Rakefile

@@ -8,7 +8,7 @@ require 'spec/rake/spectask'
 require 'rake/gempackagetask'
 
 GEM_NAME="simrpc"
-PKG_VERSION=0.2
+PKG_VERSION=0.4
 
 desc "Run all specs"
 Spec::Rake::SpecTask.new('spec') do |t|
@@ -30,11 +30,14 @@ SPEC = Gem::Specification.new do |s|
 
     s.required_ruby_version = '>= 1.8.1'
     s.required_rubygems_version = Gem::Requirement.new(">= 1.3.3")
-    # FIXME require qpid
+    s.add_development_dependency('rspec', '~> 1.3.0')
+    s.add_dependency('uuid', '~> 2.3.1')
+    s.add_dependency('activesupport', '~> 2.3.8')
+    # !!! we also need the ruby qpid wrapper. which is not currently packaged in gem form
 
     s.author = "Mohammed Morsi"
     s.email = "movitto@yahoo.com"
-    s.date = %q{2010-03-11}
+    s.date = %q{2010-09-04}
     s.description = %q{simrpc is a simple Ruby module for rpc communication, using Apache QPID as the transport mechanism.}
     s.summary     = %q{simrpc is a simple Ruby module for rpc communication, using Apache QPID as the transport mechanism.}
     s.homepage = %q{http://projects.morsi.org/Simrpc}

data/lib/simrpc.rb

@@ -30,9 +30,10 @@ lib = File.dirname(__FILE__)
 
 require lib + '/simrpc/common'
 require lib + '/simrpc/exceptions'
+require lib + '/simrpc/thread_pool'
 require lib + '/simrpc/schema'
 require lib + '/simrpc/message'
 require lib + '/simrpc/qpid_adapter'
 require lib + '/simrpc/node'
 
-require 'activesupport' # for inflector
+require 'active_support' # for inflector

data/lib/simrpc/common.rb

@@ -24,6 +24,7 @@
 # OTHER DEALINGS IN THE SOFTWARE.
 
 require 'logger'
+require 'uuid'
 
 module Simrpc
 
@@ -43,4 +44,12 @@ class Logger
     end
 end
 
+# ID bank, generates unique ids
+class IDBank
+  # FIXME right now generates uuid and grabs first 8 chars for message ids, not enough for tru randomness
+  def self.generate
+    UUID.new.generate[0...8]
+  end
 end
+
+end # module Simrpc

data/lib/simrpc/message.rb

@@ -33,15 +33,15 @@ module Message
 # Simrpc::Message formatter helper module
 class Formatter
 
-  # helper method to format a data field,
-  # prepending a fixed size to it
+  # Helper method to format a data field,
+  # prepending a size to it
   def self.format_with_size(data)
     # currently size is set to a 8 digit int
     len = "%08d" % data.to_s.size
     len + data.to_s
   end
 
-  # helper method to parse a data field
+  # Helper method to parse a data field
   # off the front of a data sequence, using the
   # formatted size. Returns parsed data field
   # and remaining data sequence. If optional
@@ -56,6 +56,24 @@ class Formatter
      return parsed, remaining if data_class.nil?
      return data_class.from_s(parsed), remaining
   end
+
+  # Helper to format a data field of a fixed size,
+  def self.format_with_fixed_size(size, data)
+    # we will only accept the first <size> characters of data
+    # FIXME throw exception if data.size < size
+    data.to_s[0..size-1]
+  end
+
+  # Helper to parse data of a fixed size and return it and the remaining data.
+  # If optional class is given, the from_s method will be invoked w/ the parsed
+  # data field and returned w/ the remaining data sequence instead
+  def self.parse_from_formatted_with_fixed_size(size, data, data_class = nil)
+    # FIXME throw exception if data.size < size
+    parsed = data[0..size-1]
+    remaining = data[size...data.size]
+    return parsed, remaining if data_class.nil?
+    return data_class.from_s(parsed), remaining
+  end
 end
 
 # a single field trasnmitted via a message,
@@ -83,19 +101,21 @@ end
 # header contains various descriptive properies
 # about a message
 class Header
-  attr_accessor :type, :target
+  attr_accessor :id, :type, :target
 
   def initialize(args = {})
+     @id     = args[:id].nil?     ? "" : args[:id]
      @type   = args[:type].nil?   ? "" : args[:type]
      @target = args[:target].nil? ? "" : args[:target]
   end
 
   def to_s
-    Formatter::format_with_size(@type) + Formatter::format_with_size(@target)
+    Formatter::format_with_fixed_size(8, @id) + Formatter::format_with_size(@type) + Formatter::format_with_size(@target)
   end
 
   def self.from_s(data)
     header = Header.new
+    header.id,     data = Formatter::parse_from_formatted_with_fixed_size(8, data)
     header.type,   data = Formatter::parse_from_formatted(data)
     header.target, data = Formatter::parse_from_formatted(data)
     return header
@@ -106,7 +126,7 @@ end
 class Body
    attr_accessor :fields
 
-   def initialize
+   def initialize(args = {})
      @fields = []
    end
 
@@ -134,9 +154,9 @@ end
 class Message
    attr_accessor :header, :body
 
-   def initialize
-      @header = Header.new
-      @body   = Body.new
+   def initialize(args = {})
+      @header = Header.new(args.has_key?(:header) ? args[:header] : {})
+      @body   = Body.new(args.has_key?(:body) ? args[:body] : {})
    end
 
    def to_s

data/lib/simrpc/node.rb

@@ -33,89 +33,71 @@ class MethodMessageController
       @schema_def = schema_def
     end
 
-    # generate new new method message, setting the message
+    # Generate new new method message, setting the message
     # target to the specified method name, and setting the fields
     # on the message to the method arguments
     def generate(method_name, args)
-       @schema_def.methods.each { |method|
-         if method.name == method_name
-           msg = Message::Message.new
-           msg.header.type = 'request'
-           msg.header.target = method.name
-
-           # loop through each param, convering corresponding
-           # argument to message field and adding it to msg
-           i = 0
-           method.parameters.each { |param|
-             field = Message::Field.new
-             field.name = param.name
-             field.value = param.to_s(args[i], @schema_def)
-             msg.body.fields.push field
-             i += 1
-           }
-
-           return msg
-         end
-       }
-       return nil
+      mmethod = @schema_def.methods.find { |method| method.name == method_name }
+      return nil if mmethod.nil?
+
+      msg = Message::Message.new :header => {:id => IDBank.generate, :type => 'request', :target => mmethod.name }
+
+      # if we have too few arguments, fill rest in w/ default values
+      if mmethod.parameters.size > args.size
+        mmethod.parameters[args.size...mmethod.parameters.size].each { |param| args << param.default }
+      end
+
+      msg.body.fields = (0...mmethod.parameters.size).collect { |i|
+        Message::Field.new(:name => mmethod.parameters[i].name,
+                           :value => mmethod.parameters[i].to_s(args[i], @schema_def))
+      }
+
+      return msg
     end
 
     # should be invoked when a message is received,
     # takes a message, converts it into a method call, and calls the corresponding
     # handler in the provided schema. Takes return arguments and sends back to caller
     def message_received(node, message, reply_to)
-       message = Message::Message::from_s(message)
-       @schema_def.methods.each { |method|
-
-         if method.name == message.header.target
-           Logger.info "received method #{method.name} message "
-
-           # for request messages, dispatch to method handler
-           if message.header.type != 'response' && method.handler != nil
-               # order the params
-               params = []
-               method.parameters.each { |data_field|
-                 value_field = message.body.fields.find { |f| f.name == data_field.name }
-                 params.push data_field.from_s(value_field.value, @schema_def) unless value_field.nil? # TODO what if value_field is nil
-               }
-
-               Logger.info "invoking #{method.name} handler "
-
-               # invoke method handler
-               return_values = method.handler.call(*params)  # FIXME handlers can't use 'return' as this will fall through here
-                                                             # FIXME throw a catch block around this call to catch all handler exceptions
-               return_values = [return_values] unless return_values.is_a? Array
-
-               # if method returns no values, do not return response
-               unless method.return_values.size == 0
-
-                  # consruct and send response message using return values
-                  response = Message::Message.new
-                  response.header.type = 'response'
-                  response.header.target = method.name
-                  (0...method.return_values.size).each { |rvi|
-                    field = Message::Field.new
-                    field.name = method.return_values[rvi].name
-                    field_def = method.return_values.find { |rv| rv.name == field.name }
-                    field.value = field_def.to_s(return_values[rvi], @schema_def) unless field_def.nil? # TODO what if field_def is nil
-                    response.body.fields.push field
-                  }
-                  Logger.info "responding to #{reply_to}"
-                  node.send_message(reply_to, response)
-
-               end
-
-           # for response values just return converted return values
-           else
-               results = []
-               method.return_values.each { |data_field|
-                 value_field = message.body.fields.find { |f| f.name == data_field.name }
-                 results.push data_field.from_s(value_field.value, @schema_def) unless value_field.nil? # TODO what if value_field is nil
-               }
-               return results
-           end
-         end
-       }
+      message = Message::Message::from_s(message)
+      mmethod = @schema_def.methods.find { |method| method.name == message.header.target }
+      return nil if mmethod.nil?
+
+      Logger.info "received method #{mmethod.name} message "
+
+      # For request messages, dispatch to method handler
+      if message.header.type == 'request'
+        return nil if mmethod.handler.nil?
+
+        # collect the method params
+        params = (0...mmethod.parameters.size).collect { |i| mmethod.parameters[i].from_s(message.body.fields[i].value, @schema_def) }
+
+        Logger.info "invoking #{mmethod.name} handler "
+
+        # invoke method handler
+        return_values = mmethod.handler.call(*params)  # FIXME handlers can't use 'return' as this will fall through here
+                                                      # FIXME throw a catch block around this call to catch all handler exceptions
+        return_values = [return_values] unless return_values.is_a? Array
+
+        # consruct and send response message using return values
+        response = Message::Message.new :header => {:id => message.header.id, :type => 'response', :target => mmethod.name }
+        response.body.fields = (0...mmethod.return_values.size).collect { |i|
+          field_def = mmethod.return_values[i]
+          Message::Field.new :name => field_def.name, :value => field_def.to_s(return_values[i], @schema_def)
+          # TODO if mmethod.return_values.size > return_values.size, fill in w/ default values
+        }
+        Logger.info "responding to #{reply_to}"
+        node.send_message(reply_to, response)
+        return message.header.id, params
+
+      # For response values just return converted return values
+      else
+        results = (0...mmethod.return_values.size).collect { |i|
+          mmethod.return_values[i].from_s(message.body.fields[i].value, @schema_def)
+        }
+        return message.header.id, results
+
+      end
     end
 end
 
@@ -140,15 +122,17 @@ class Node
       end
       raise ArgumentError, "schema_def cannot be nil" if @schema_def.nil?
       @mmc = MethodMessageController.new(@schema_def)
-      @message_lock = Semaphore.new(1)
-      @message_lock.wait
+
+      # hash of message id's -> response locks
+      @message_locks = {}
 
       # FIXME currently not allowing for any other params to be passed into
       # QpidAdapter::Node such as broker ip or port, NEED TO FIX THIS
+      # NOTE see QpidAdapter::Node for limitation on using 'inspect'
       @qpid_node = QpidAdapter::Node.new(:id => @id)
       @qpid_node.async_accept { |node, msg, reply_to|
-          results = @mmc.message_received(node, msg, reply_to)
-          message_received(results)
+          mid, results = @mmc.message_received(node, msg, reply_to)
+          message_received(mid, results)
       }
    end
 
@@ -158,9 +142,14 @@ class Node
    end
 
    # implements, message_received callback to be notified when qpid receives a message
-   def message_received(results)
-       @message_results = results
-       @message_lock.signal
+   def message_received(mid, results)
+       @message_results = results unless results.nil?
+       @message_locks[mid].signal unless mid.nil? || !@message_locks.has_key?(mid)
+   end
+
+   # Terminate node operations
+   def terminate
+     @qpid_node.terminate
    end
 
    # wait until the node is no longer accepting messages
@@ -188,12 +177,16 @@ class Node
 
       # block if we are expecting return values
       if @schema_def.methods.find{|m| m.name == method_name}.return_values.size != 0
-        @message_lock.wait # block until response received
+        @message_locks[msg.header.id] =  Semaphore.new(1)
+        @message_locks[msg.header.id].wait
+        @message_locks[msg.header.id].wait # block until response received
+        @message_locks.delete(msg.header.id)
 
         # return return values
         #@message_received.body.fields.collect { |f| f.value }
         return *@message_results
       end
+      return nil
    end
 
    # can invoke schema methods directly on Node instances, this will catch

data/lib/simrpc/qpid_adapter.rb

@@ -37,7 +37,8 @@ module QpidAdapter
 # network which has its own exchange and queue which it listens on
 class Node
  private
-  # helper method to generate a random id
+  # Helper method to generate a random id
+  # TODO use uuid since we're pulling in that gem anyways for message ids
   def gen_uuid
     ["%02x"*4, "%02x"*2, "%02x"*2, "%02x"*2, "%02x"*6].join("-") %
         Array.new(16) {|x| rand(0xff) }
@@ -77,6 +78,9 @@ class Node
      end
 
      ### create underlying tcp connection
+     # NOTE pretty big bug in ruby/qpid preventing us from using 'inspect'
+     # on this class (causes segfault)
+     # https://issues.apache.org/jira/browse/QPID-2405
      @conn = Qpid::Connection.new(TCPSocket.new(broker,port))
      @conn.start
 
@@ -85,6 +89,10 @@ class Node
 
      @children = {}
 
+     # threads pool to handle incoming requests
+     # FIXME make the # of threads and timeout configurable)
+     @thread_pool = ThreadPool.new(10, :timeout => 5)
+
      @accept_lock = Semaphore.new(1)
 
      # qpid constructs that will be created for node
@@ -126,28 +134,34 @@ class Node
 
      # start receiving messages
      @incoming.listen{ |msg|
-        Logger.info "queue #{@queue} received message #{msg.body.to_s.size} #{msg.body}"
+        Logger.info "queue #{@queue} received message #{msg.body}"
         reply_to = msg.get(:message_properties).reply_to.routing_key
-        handler.call(self, msg.body, reply_to)
+        # FIXME should delete handler threads as they complete
+        # FIXME handler timeout
+        job = ThreadPoolJob.new { handler.call(self, msg.body, reply_to) }
+        @thread_pool << job
      }
   end
 
   # block until accept operation is complete
   def join
      @accept_lock.wait
+     #FIXME @thread_pool.join
   end
 
   # instructs QpidServer to stop accepting, blocking
   # untill all accepting operations have terminated
   def terminate
     Logger.warn "terminating qpid session"
+    @thread_pool.stop
     unless @incoming.nil?
       @incoming.stop
       @incoming.close
       @accept_lock.signal
     end
+    @ssn.queue_delete(@queue)
+    @ssn.exchange_delete(@exchange)
     @ssn.close
-    # TODO undefine the @queue/@exchange
   end
 
   # send a message to the specified routing_key

data/lib/simrpc/schema.rb

@@ -66,9 +66,12 @@ module_function :primitive_from_str
 class DataFieldDef
   attr_accessor :type, :name, :associated
 
-  # indicates this data field should be ignored if it has a null value
+  # Indicates this data field should be ignored if it has a null value
   attr_accessor :ignore_null
 
+  # Indicates the default value of the field
+  attr_accessor :default
+
   def initialize(args = {})
      @type = args[:type] unless args[:type].nil?
      @name = args[:name] unless args[:name].nil?
@@ -138,7 +141,7 @@ class DataFieldDef
   # Provide schema_def for :obj or :array data fields associated w/ non-primitive types
   # # coverted_classes is a recursive helper array used/maintained internally
   def from_s(str, schema_def = nil, converted_classes = [])
-    if str == ""
+    if str == "" # || str == "nil" # FIXME uncomment & test
       return nil
 
     elsif Schema::is_primitive?(@type)
@@ -390,8 +393,10 @@ class Parser
      data_field = DataFieldDef.new
      data_field.type = element.attributes["type"].intern
      data_field.name = element.attributes["name"]
+     data_field.default = data_field.from_s(element.attributes["default"]) unless element.attributes["default"].nil?
      data_field.associated = element.attributes["associated"].intern unless element.attributes["associated"].nil?
      data_field.ignore_null = true if element.attributes.include? "ignore_null"
+     data_field
      return data_field
    end
 end

data/lib/simrpc/thread_pool.rb

@@ -0,0 +1,137 @@
+# Thread Pool
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+#
+# Permission is hereby granted, free of charge, to any person
+# obtaining a copy of this software and associated documentation
+# files (the "Software"), to deal in the Software without
+# restriction, including without limitation the rights to use,
+# copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following
+# conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.
+
+require 'thread'
+
+module Simrpc
+
+  # Work item to be executed in thread pool
+  class ThreadPoolJob
+    attr_accessor :handler
+    attr_accessor :params
+
+    def initialize(*params, &block)
+      @params = params
+      @handler = block
+    end
+  end
+
+  # ActiveObject pattern, encapsulate each thread pool thread in object
+  class ThreadPoolJobRunner
+    attr_accessor :time_started
+
+    def initialize(thread_pool)
+      @thread_pool = thread_pool
+    end
+
+    def run
+      @thread = Thread.new {
+        until @thread_pool.terminate
+          work = @thread_pool.next_job
+          @time_started = Time.now
+          work.handler.call *work.params unless work.nil?
+          @time_started = nil
+        end
+      }
+    end
+
+    def stop
+      @thread.kill
+      @thread.join
+    end
+
+    def join
+      @thread.join
+    end
+  end
+
+  # Launches a specified number of threads on instantiation,
+  # assigning work to them as it arrives
+  class ThreadPool
+    attr_accessor :terminate
+
+    # Create a thread pool with a specified number of threads
+    def initialize(num_threads, args = {})
+      @num_threads = num_threads
+      @timeout     = args[:timeout]
+      @job_runners = []
+      @work_queue  = []
+      @work_queue_lock = Mutex.new
+      @work_queue_cv = ConditionVariable.new
+
+      @terminate = false
+
+      0.upto(@num_threads) { |i| 
+        runner = ThreadPoolJobRunner.new(self)
+        @job_runners << runner
+        runner.run
+      }
+
+      # optional timeout thread
+      unless @timeout.nil?
+        @timeout_thread = Thread.new {
+          until @terminate
+            sleep @timeout
+            @job_runners.each { |jr|
+              if !jr.time_started.nil? && (Time.now - jr.time_started > @timeout)
+                jr.stop
+                jr.run
+              end
+            }
+          end
+        }
+      end
+    end
+
+    # Add work to the pool
+    def <<(work)
+      @work_queue_lock.synchronize {
+        @work_queue << work
+        @work_queue_cv.signal
+      }
+    end
+
+    # Return the next job queued up, blocking until one is received 
+    # if none are present
+    def next_job
+      work = nil
+      @work_queue_lock.synchronize {
+        # wait until we have work
+        @work_queue_cv.wait(@work_queue_lock) if @work_queue.empty?
+        work = @work_queue.shift
+      }
+      work
+    end
+
+    # Terminate the thread pool
+    def stop
+      @terminate = true
+      @work_queue_lock.synchronize {
+        @work_queue.clear
+      }
+      @job_runners.each { |jr| jr.stop }
+    end
+  end
+end

data/spec/common_spec.rb

@@ -24,3 +24,13 @@
 # OTHER DEALINGS IN THE SOFTWARE.
 
 require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Simrpc" do
+
+  it "should generate unique ids" do
+    id1 = IDBank.generate
+    id2 = IDBank.generate
+    id1.should_not == id2
+  end
+
+end

data/spec/message_spec.rb

@@ -35,6 +35,12 @@ describe "Simrpc::Message" do
      assert_equal ["foobar", ""], Message::Formatter::parse_from_formatted(formatted)
   end
 
+  it "should format and parsed a data field with a fixed size" do
+     formatted = Message::Formatter::format_with_fixed_size(3, 123456)
+     formatted.should == "123"
+     assert_equal ["123", ""], Message::Formatter::parse_from_formatted_with_fixed_size(3, formatted)
+  end
+
   it "should convert a field to and from a string" do
      field = Message::Field.new(:name => "foo", :value => "bar")
      field_s = field.to_s
@@ -72,13 +78,14 @@ describe "Simrpc::Message" do
 
   it "should convert a message to and from a string" do
      msg = Message::Message.new
+     msg.header.id = "12345678"
      msg.header.type = 'request'
      msg.header.target = 'method'
      msg.body.fields.push Message::Field.new(:name => "foo", :value => "bar")
      msg.body.fields.push Message::Field.new(:name => "money", :value => "lotsof")
      msg_s = msg.to_s
 
-     msg_s.should == "0000002900000007request00000006method000000650000002200000003foo00000003bar0000002700000005money00000006lotsof"
+     msg_s.should == "000000371234567800000007request00000006method000000650000002200000003foo00000003bar0000002700000005money00000006lotsof"
      
      msg_o = Message::Message.from_s(msg_s)
      msg_o.header.type.should == 'request'

data/spec/node_spec.rb

@@ -70,9 +70,43 @@ describe "Simrpc::Node" do
       client.send_message("server-queue", msg)
       finished_lock.wait()
 
+      server.terminate
+      client.terminate
+
       # FIXME test method that doesn't have any return values
   end
 
+  it "should handle default values" do
+      schema_def = Schema::Parser.parse(:schema => TEST_SCHEMA)
+      mmc = MethodMessageController.new(schema_def)
+      msg = mmc.generate('foo_method', [2])
+
+      finished_lock = Semaphore.new(1)
+      finished_lock.wait()
+
+      schema_def.methods[0].handler = lambda { |some_int, floating_point_number|
+        some_int.to_i.should == 2
+        floating_point_number.to_f.should == 5.6 # test default value
+        return "yo", MyClass.new
+      }
+
+      server  = QpidAdapter::Node.new :id => "server"
+      server.async_accept { |node, msg, reply_to|
+        mmc.message_received(node, msg, reply_to)
+      }
+
+      client = QpidAdapter::Node.new :id => 'client'
+      client.async_accept { |node, msg, reply_to|
+         #msg = Message::Message.from_s(msg)
+         finished_lock.signal()
+      }
+      client.send_message("server-queue", msg)
+      finished_lock.wait()
+
+      server.terminate
+      client.terminate
+  end
+
   it "it should run properly" do
      server = Node.new(:id => "server3", :schema => TEST_SCHEMA)
      client = Node.new(:id => "client3", :schema => TEST_SCHEMA, :destination => "server3")
@@ -94,6 +128,9 @@ describe "Simrpc::Node" do
      my_class_instance.float_member.should == 4.2
 
       # FIXME test method that doesn't have any return values
+
+      client.terminate
+      server.terminate
   end
 
 end

data/spec/qpid_spec.rb

@@ -38,6 +38,7 @@ describe "Simrpc::QpidAdapter" do
     ssn.error?.should == false
     #ssn.closed.should == false
     id.should == "test1"
+    qpid.terminate
   end
 
   # ensure we define a queue and exchange
@@ -67,6 +68,21 @@ describe "Simrpc::QpidAdapter" do
      #assert !binding_result.queue_not_found?
      #assert !binding_result.queue_not_matched?
      #assert !binding_result.key_not_found?
+
+     node.terminate
+  end
+
+  it "should terminate queue and exchange" do
+    node  = QpidAdapter::Node.new :id => "qpid_test3"
+    node.terminate
+
+    # need to start a new session since terminate closes the previous one
+    conn = Qpid::Connection.new(TCPSocket.new('localhost', 5672))
+    conn.start
+    ssn = conn.session(UUID.new.generate)
+
+    assert ssn.queue_query("qpid_test3-queue").queue.nil?
+    assert ssn.exchange_query("qpid_test3-exchange").not_found
   end
 
   # test sending/receiving a message
@@ -87,6 +103,9 @@ describe "Simrpc::QpidAdapter" do
     }
     client.send_message("server1-queue", "test-data")
     finished_lock.wait()
+
+    server.terminate
+    client.terminate
   end
 
 end

data/spec/schema_spec.rb

@@ -49,6 +49,7 @@ describe "Simrpc::Schema" do
      schema_def.methods[0].parameters[0].name.should == 'some_int'
      schema_def.methods[0].parameters[1].type.should == :float
      schema_def.methods[0].parameters[1].name.should == 'floating_point_number'
+     schema_def.methods[0].parameters[1].default.should == 5.6
      schema_def.methods[0].return_values.size.should == 2
      schema_def.methods[0].return_values[0].type.should == :str
      schema_def.methods[0].return_values[0].name.should == 'a_string'

data/spec/spec_helper.rb

@@ -40,7 +40,7 @@ TEST_SCHEMA =
          "<schema>"+
          "  <method name='foo_method'>" +
          "    <param type='int' name='some_int'/>"+
-         "    <param type='float' name='floating_point_number'/>"+
+         "    <param type='float' name='floating_point_number' default='5.6' />"+
          "    <return_value type='str' name='a_string' />" +
          "    <return_value type='obj' name='my_class_instance' associated='MyClass' />" +
          "  </method>"+

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: simrpc
 version: !ruby/object:Gem::Version 
-  version: "0.2"
+  hash: 3
+  prerelease: false
+  segments: 
+  - 0
+  - 4
+  version: "0.4"
 platform: ruby
 authors: 
 - Mohammed Morsi
@@ -9,10 +14,57 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-11 00:00:00 -05:00
+date: 2010-09-04 00:00:00 -04:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: uuid
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 2
+        - 3
+        - 1
+        version: 2.3.1
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 2
+        - 3
+        - 8
+        version: 2.3.8
+  type: :runtime
+  version_requirements: *id003
 description: simrpc is a simple Ruby module for rpc communication, using Apache QPID as the transport mechanism.
 email: movitto@yahoo.com
 executables: []
@@ -25,6 +77,7 @@ files:
 - lib/simrpc/message.rb
 - lib/simrpc/common.rb
 - lib/simrpc/semaphore.rb
+- lib/simrpc/thread_pool.rb
 - lib/simrpc/qpid_adapter.rb
 - lib/simrpc/exceptions.rb
 - lib/simrpc/schema.rb
@@ -49,21 +102,31 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 53
+      segments: 
+      - 1
+      - 8
+      - 1
       version: 1.8.1
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 29
+      segments: 
+      - 1
+      - 3
+      - 3
       version: 1.3.3
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: simrpc is a simple Ruby module for rpc communication, using Apache QPID as the transport mechanism.