spqr 0.3.1 → 0.3.2

data/CHANGES

@@ -1,4 +1,10 @@
-version 0.3.1
+version 0.3.2
+
+*  far less verbose debugging information
+*  is_tracked declaration to automatically track instances of (non-Rhubarb) managed classes.
+*  SPQR now respects access annotations on property declarations.  (obs. from Ian McLeod)
+
+version 0.3.1 (e3e3729bef42fd7a5315356c85ddf30939759b34)
 
 *  "qmf_singleton" declaration for boilerplate-free singleton classes
 

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.3.2

data/lib/spqr/app.rb

@@ -92,6 +92,7 @@ module SPQR
 
 
     def method_call(context, name, obj_id, args, user_id)
+      @log.debug("method_call(#{context.inspect}, #{name.inspect}, #{obj_id.inspect}, #{args.inspect}, #{user_id.inspect})")
       begin
         status = 0
         message = "OK"
@@ -103,8 +104,6 @@ module SPQR
         Thread.current[:qmf_user_id] = user_id
         Thread.current[:qmf_context] = context
 
-        @log.debug "calling method: context=#{context} method=#{name} object_id=#{obj_id}, user=#{user_id}"
-
         managed_object = find_object(context, class_id, obj_id)
         @log.debug("managed object is #{managed_object}")
         managed_method = managed_object.class.spqr_meta.mmethods[name.to_sym]
@@ -112,15 +111,8 @@ module SPQR
         raise RuntimeError.new("#{managed_object.class} does not have #{name} exposed as a manageable method; has #{managed_object.class.spqr_meta.mmethods.inspect}") unless managed_method
 
         # Extract actual parameters from the Qmf::Arguments structure into a proper ruby list
-        @log.debug("actual params are: #{args.instance_variable_get(:@by_hash).inspect}") rescue nil
         actuals_in = managed_method.formals_in.inject([]) {|acc,nm| acc << args[nm]}
         actual_count = actuals_in.size
-
-        @log.debug("managed_object.respond_to? #{managed_method.name.to_sym} ==> #{managed_object.respond_to? managed_method.name.to_sym}")
-        @log.debug("managed_object.class.spqr_meta.mmethods.include? #{name.to_sym} ==> #{managed_object.class.spqr_meta.mmethods.include? name.to_sym}")
-        @log.debug("formals:  #{managed_method.formals_in.inspect}")
-        @log.debug("actuals:  #{actuals_in.inspect}")
-
         actuals_out = []
 
         begin
@@ -133,7 +125,7 @@ module SPQR
           raise RuntimeError.new("#{managed_object.class} did not return the appropriate number of return values; got '#{actuals_out.inspect}', but expected #{managed_method.types_out.inspect}") unless result_valid(actuals_out, managed_method)
           
         rescue ::SPQR::ManageableObjectError => failure
-          @log.info "#{name} called SPQR::Manageable#fail:  #{failure}"
+          @log.warn "#{name} called SPQR::Manageable#fail:  #{failure}"
           status = failure.status
           message = failure.message || "ERROR"
           # XXX:  failure.result is currently ignored
@@ -146,9 +138,6 @@ module SPQR
         elsif managed_method.formals_out.size == 1
           actuals_out = [actuals_out] # wrap this up in a list
         end
-        
-        @log.debug("formals_out == #{managed_method.formals_out.inspect}")
-        @log.debug("actuals_out == #{actuals_out.inspect}")
 
         unless failed
           # Copy any out parameters from return value to the
@@ -169,7 +158,7 @@ module SPQR
     end
 
     def get_query(context, query, user_id)
-      @log.debug "query: user=#{user_id} context=#{context} class=#{query.class_name} object_num=#{query.object_id.object_num_low if query.object_id} details=#{query} haveSelect=#{query.impl and query.impl.haveSelect} getSelect=#{query.impl and query.impl.getSelect} (#{query.impl and query.impl.getSelect and query.impl.getSelect.methods.inspect})"
+      @log.debug "get_query: user=#{user_id} context=#{context} class=#{query.class_name} object_num=#{query.object_id && query.object_id.object_num_low} details=#{query}"
 
       cmeta = @classes_by_name[query.class_name]
       objs = []
@@ -188,11 +177,10 @@ module SPQR
       end
 
       objs.each do |obj| 
-        @log.debug("query_response of: #{obj.inspect}")
         @agent.query_response(context, obj) rescue @log.error($!.inspect)
       end
       
-      @log.debug("completing query....")
+      @log.debug("completing query; returned #{objs.size} objects")
       @agent.query_complete(context)
     end
 
@@ -264,9 +252,7 @@ module SPQR
 
     def find_object(ctx, c_id, obj_id)
       # XXX:  context is currently ignored
-      @log.debug("in find_object; class ID is #{c_id}, object ID is #{obj_id}...")
       klass = @classes_by_id[c_id]
-      @log.debug("found class #{klass.inspect}")
       klass.find_by_id(obj_id) if klass
     end
     
@@ -317,6 +303,7 @@ module SPQR
       collection.each do |basic|
         basic_name = basic.name.to_s
         basic_type = get_xml_constant(basic.kind.to_s, ::SPQR::XmlConstants::Type)
+        basic.options[:access] = get_xml_constant(basic.options[:access].to_s.upcase, ::SPQR::XmlConstants::Access) if basic.options[:access]
         @log.debug("+-- creating a QMF schema for #{what} #{basic_name} (#{basic_type}) with options #{basic.options.inspect}")
         sc.send(msg, klass.new(basic_name, basic_type, basic.options))
       end
@@ -326,7 +313,7 @@ module SPQR
     
     # turns an instance of a managed object into a QmfObject
     def qmfify(obj)
-      @log.debug("trying to qmfify #{obj}:  qmf_oid is #{obj.qmf_oid} and class_id is #{obj.class.class_id}")
+      @log.debug("qmfify: treating instance of #{obj.class.name}:  qmf_oid is #{obj.qmf_oid} and class_id is #{obj.class.class_id}")
       cm = @classes_by_name[obj.class.spqr_meta.classname.to_s]
       return nil unless cm
 
@@ -334,13 +321,8 @@ module SPQR
 
       set_attrs(qmfobj, obj)
 
-      @log.debug("calling alloc_object_id(#{obj.qmf_oid}, #{obj.class.class_id})")
       oid = @agent.alloc_object_id(obj.qmf_oid, obj.class.class_id)
-      
-      @log.debug("calling qmfobj.set_object_id(#{oid})")
       qmfobj.set_object_id(oid)
-      
-      @log.debug("returning from qmfify")
       qmfobj
     end
 
@@ -351,7 +333,6 @@ module SPQR
 
       attrs.each do |a|
         getter = a.name.to_s
-        @log.debug("setting property/statistic #{getter} to its value from #{o}: #{o.send(getter) if o.respond_to?(getter)}")
         value = o.send(getter) if o.respond_to?(getter)
 
         if value || a.kind == :bool

data/lib/spqr/manageable.rb

@@ -159,7 +159,9 @@ module SPQR
       spqr_meta.declare_method(name, description, options, blk)
     end
 
-    def qmf_singleton
+    # Declares that this class is a singleton class; that is, only one
+    # instance will be published over QMF
+    def is_singleton
       def self.instances
         @instances ||= [self.new]
       end
@@ -173,6 +175,40 @@ module SPQR
       end
     end
 
+    # Declares that instances of this class will automatically be
+    # tracked (and find_all and find_by_id methods generated).
+    # Instances of automatically-tracked classes must be explicitly
+    # deleted (with the delete class method).  Do not use automatic
+    # tracking with Rhubarb, which automatically tracks instances for
+    # you.
+    def is_tracked
+      # no pun intended, I promise
+      alias_method :old_new, :new
+      
+      def self.instances
+        @instances ||= {}
+      end
+
+      def self.find_all
+        instances.values
+      end
+
+      def self.find_by_id(id)
+        instances[id]
+      end
+      
+      # XXX:  would it make more sense to call allocate and initialize explicitly?
+      def self.new(*args)
+        result = old_new(*args)
+        instances[result.qmf_oid] = result
+        result
+      end
+
+      def self.delete(instance)
+        instances.delete(instance.qmf_oid)
+      end
+    end
+
     def qmf_package_name(nm)
       spqr_meta.package = nm
     end
@@ -294,6 +330,7 @@ module SPQR
     def self.included(other)
       class << other
         include ManageableClassMixins
+        alias_method :qmf_singleton, :is_singleton
       end
 
       unless other.respond_to? :find_by_id

data/ruby-spqr.spec.in

@@ -70,6 +70,11 @@ rm -rf %{buildroot}
 
 %changelog
 
+* Wed Sep 15 2010  <willb@redhat> - 0.3.2-1
+- updated to version 0.3.2-1
+- removed spurious debugging output
+- access modifiers now respected on properties 
+
 * Mon May 10 2010  <willb@redhat> - 0.3.0-1
 - updated to version 0.3.0-1
 

data/test/example-apps.rb

@@ -95,7 +95,7 @@ class QmfDummyProp
     "DummyPropService"
   end
   
-  qmf_property :service_name, :lstr
+  qmf_property :service_name, :lstr, :access=>"RW"
 
   qmf_class_name :QmfDummyProp
   qmf_package_name :example

data/test/standalone-test.rb

@@ -0,0 +1,330 @@
+require 'qmf'
+
+class App < Qmf::AgentHandler
+  class ClassMeta < Struct.new(:object_class, :schema_class) ; end
+
+  attr_reader :agent
+
+  def initialize(options=nil)
+    defaults = {:logfile=>STDERR, :loglevel=>Logger::WARN, :notifier=>nil, :server=>"localhost", :port=>5672}
+    
+    # convenient shorthands for log levels
+    loglevels = {:debug => Logger::DEBUG, :info => Logger::INFO, :warn => Logger::WARN, :error => Logger::ERROR, :fatal => Logger::FATAL}
+      
+    options = defaults unless options
+
+    # set unsupplied options to defaults
+    defaults.each do |k,v|
+      options[k] = v unless options[k]
+    end
+
+    # fix up shorthands
+    options[:loglevel] = loglevels[options[:loglevel]] if loglevels[options[:loglevel]]
+
+    logger_opts = ([options[:logfile]] + [options[:logoptions]]).flatten.compact
+
+    @log = Logger.new(*logger_opts)
+    @log.level = options[:loglevel]
+
+    @log.info("initializing SPQR app....")
+
+    @classes_by_name = {}
+    @classes_by_id = {}
+    @pipe = options[:notifier]
+    @app_name = (options[:appname] or "SPQR application [#{Process.pid}]")
+    @qmf_host = options[:server]
+    @qmf_port = options[:port]
+    @qmf_sendUserId = if options.has_key?(:send_user_id)
+                        options[:send_user_id]
+                      else
+                        (options.has_key?(:user) || options.has_key?(:password))
+                      end
+    
+    @qmf_user = options[:user]
+    @qmf_password = options[:password]
+  end
+
+  def register(*ks)
+    manageable_ks = ks.select {|kl| manageable? kl}
+    unmanageable_ks = ks.select {|kl| not manageable? kl}
+    manageable_ks.each do |klass|
+      schemaclass = schematize(klass)
+
+      klass.log = @log
+      
+      # XXX
+      if klass.included_modules.include?(::SPQR::Manageable)
+        @classes_by_id[klass.class_id] = klass        
+        @classes_by_name[klass.spqr_meta.classname.to_s] = ClassMeta.new(klass, schemaclass)
+      else
+        @log.info "NOT registering query/lookup info for #{klass}; is it an event class?"
+      end
+
+      @log.info("SETTING #{klass.spqr_meta.classname}.app to #{self.inspect}")
+      klass.app = self        
+    end
+    
+    unmanageable_ks.each do |klass|
+      @log.warn("SPQR can't manage #{klass}, which was registered")
+    end
+  end
+
+
+  def method_call(context, name, obj_id, args, user_id)
+    begin
+      status = 0
+      message = "OK"
+      failed = false
+
+      class_id = obj_id.object_num_high
+      obj_id = obj_id.object_num_low
+
+      Thread.current[:qmf_user_id] = user_id
+      Thread.current[:qmf_context] = context
+
+      @log.debug "calling method: context=#{context} method=#{name} object_id=#{obj_id}, user=#{user_id}"
+
+      managed_object = find_object(context, class_id, obj_id)
+      @log.debug("managed object is #{managed_object}")
+      managed_method = managed_object.class.spqr_meta.mmethods[name.to_sym]
+
+      raise RuntimeError.new("#{managed_object.class} does not have #{name} exposed as a manageable method; has #{managed_object.class.spqr_meta.mmethods.inspect}") unless managed_method
+
+      # Extract actual parameters from the Qmf::Arguments structure into a proper ruby list
+      @log.debug("actual params are: #{args.instance_variable_get(:@by_hash).inspect}") rescue nil
+      actuals_in = managed_method.formals_in.inject([]) {|acc,nm| acc << args[nm]}
+      actual_count = actuals_in.size
+
+      @log.debug("managed_object.respond_to? #{managed_method.name.to_sym} ==> #{managed_object.respond_to? managed_method.name.to_sym}")
+      @log.debug("managed_object.class.spqr_meta.mmethods.include? #{name.to_sym} ==> #{managed_object.class.spqr_meta.mmethods.include? name.to_sym}")
+      @log.debug("formals:  #{managed_method.formals_in.inspect}")
+      @log.debug("actuals:  #{actuals_in.inspect}")
+
+      actuals_out = []
+
+      begin
+        actuals_out = case actual_count
+          when 0 then managed_object.send(name.to_sym)
+          when 1 then managed_object.send(name.to_sym, actuals_in[0])
+          else managed_object.send(name.to_sym, *actuals_in)
+        end
+        
+        raise RuntimeError.new("#{managed_object.class} did not return the appropriate number of return values; got '#{actuals_out.inspect}', but expected #{managed_method.types_out.inspect}") unless result_valid(actuals_out, managed_method)
+        
+      rescue ::SPQR::ManageableObjectError => failure
+        @log.info "#{name} called SPQR::Manageable#fail:  #{failure}"
+        status = failure.status
+        message = failure.message || "ERROR"
+        # XXX:  failure.result is currently ignored
+        actuals_out = failure.result || managed_method.formals_out.inject([]) {|acc, val| acc << args[val]; acc}
+        failed = true
+      end
+      
+      if managed_method.formals_out.size == 0
+        actuals_out = [] # ignore return value in this case
+      elsif managed_method.formals_out.size == 1
+        actuals_out = [actuals_out] # wrap this up in a list
+      end
+      
+      @log.debug("formals_out == #{managed_method.formals_out.inspect}")
+      @log.debug("actuals_out == #{actuals_out.inspect}")
+
+      unless failed
+        # Copy any out parameters from return value to the
+        # Qmf::Arguments structure; see XXX above
+        managed_method.formals_out.zip(actuals_out).each do |k,v|
+          @log.debug("fixing up out params:  #{k.inspect} --> #{v.inspect}")
+          encoded_val = encode_object(v)
+          args[k] = encoded_val
+        end
+      end
+
+      @agent.method_response(context, status, message, args)
+    rescue Exception => ex
+      @log.error "Error calling #{name}: #{ex}"
+      @log.error "    " + ex.backtrace.join("\n    ")
+      @agent.method_response(context, 1, "ERROR: #{ex}", args)
+    end
+  end
+
+  def get_query(context, query, user_id)
+    @log.debug "query: user=#{user_id} context=#{context} class=#{query.class_name} object_num=#{query.object_id.object_num_low if query.object_id} details=#{query} haveSelect=#{query.impl and query.impl.haveSelect} getSelect=#{query.impl and query.impl.getSelect} (#{query.impl and query.impl.getSelect and query.impl.getSelect.methods.inspect})"
+
+    cmeta = @classes_by_name[query.class_name]
+    objs = []
+    
+    # XXX:  are these cases mutually exclusive?
+    
+    # handle queries for a certain class
+    if cmeta
+      objs = objs + cmeta.object_class.find_all.collect {|obj| qmfify(obj)}
+    end
+
+    # handle queries for a specific object
+    o = find_object(context, query.object_id.object_num_high, query.object_id.object_num_low) rescue nil
+    if o
+      objs << qmfify(o)
+    end
+
+    objs.each do |obj| 
+      @log.debug("query_response of: #{obj.inspect}")
+      @agent.query_response(context, obj) rescue @log.error($!.inspect)
+    end
+    
+    @log.debug("completing query....")
+    @agent.query_complete(context)
+  end
+
+  def main
+    settings = Qmf::ConnectionSettings.new
+    settings.host = @qmf_host
+    settings.port = @qmf_port
+    settings.sendUserId = @qmf_sendUserId
+    
+    settings.username = @qmf_user if @qmf_sendUserId
+    settings.password = @qmf_password if @qmf_sendUserId
+    
+    @schemaclass = Qmf::SchemaObjectClass.new("test", "testclass")
+    
+    @connection = Qmf::Connection.new(settings)
+    @log.debug(" +-- @connection created:  #{@connection}")
+    @log.debug(" +-- app name is '#{@app_name}'")
+
+    @agent = Qmf::Agent.new(self, @app_name)
+    @log.debug(" +-- @agent created:  #{@agent}")
+
+    @agent.set_connection(@connection)
+    @log.debug(" +-- @agent.set_connection called")
+
+    @log.debug(" +-- registering classes...")
+    @classes_by_name.values.each do |km| 
+      @agent.register_class(km.schema_class) 
+      @log.debug(" +--+-- #{km.schema_class.package_name} #{km.schema_class.class_name} registered")
+    end
+    
+    @log.debug("entering orbit....")
+
+    sleep
+  end
+
+  private
+  
+  def result_valid(actuals, mm)
+    (actuals.kind_of?(Array) and mm.formals_out.size == actuals.size) or mm.formals_out.size <= 1
+  end
+  
+  def qmf_arguments_to_hash(args)
+    result = {}
+    args.each do |k,v|
+      result[k] = v
+    end
+    result
+  end
+
+  def encode_object(o)
+    return o unless o.kind_of? ::SPQR::Manageable
+    @agent.alloc_object_id(*(o.qmf_id))
+  end
+
+  def find_object(ctx, c_id, obj_id)
+    # XXX:  context is currently ignored
+    @log.debug("in find_object; class ID is #{c_id}, object ID is #{obj_id}...")
+    klass = @classes_by_id[c_id]
+    @log.debug("found class #{klass.inspect}")
+    klass.find_by_id(obj_id) if klass
+  end
+  
+  def schematize(klass)
+    @log.info("Making a QMF schema for #{klass.spqr_meta.classname}")
+
+    if klass.respond_to? :schematize
+      @log.info("#{klass.spqr_meta.classname} knows how to schematize itself; it's probably an event class")
+      return klass.schematize 
+    else
+      @log.info("#{klass.spqr_meta.classname} doesn't know how to schematize itself; it's probably an object class")
+      return schematize_object_class(klass)
+    end
+  end
+  
+  def schematize_object_class(klass)
+    meta = klass.spqr_meta
+    package = meta.package.to_s
+    classname = meta.classname.to_s
+    @log.info("+-- class #{classname} is in package #{package}")
+
+    sc = Qmf::SchemaObjectClass.new(package, classname)
+    
+    meta.manageable_methods.each do |mm|
+      @log.info("+-- creating a QMF schema for method #{mm}")
+      m_opts = mm.options
+      m_opts[:desc] ||= mm.description if mm.description
+      
+      method = Qmf::SchemaMethod.new(mm.name.to_s, m_opts)
+      
+      mm.args.each do |arg| 
+        @log.info("| +-- creating a QMF schema for arg #{arg}")
+        
+        encode_argument(arg, method)
+      end
+
+      sc.add_method(method)
+    end
+
+    add_attributes(sc, meta.properties, :add_property, Qmf::SchemaProperty)
+    add_attributes(sc, meta.statistics, :add_statistic, Qmf::SchemaStatistic)
+
+    sc
+  end
+  
+  def add_attributes(sc, collection, msg, klass, what=nil)
+    what ||= (msg.to_s.split("_").pop rescue "property or statistic")
+    collection.each do |basic|
+      basic_name = basic.name.to_s
+      basic_type = get_xml_constant(basic.kind.to_s, ::SPQR::XmlConstants::Type)
+      @log.debug("+-- creating a QMF schema for #{what} #{basic_name} (#{basic_type}) with options #{basic.options.inspect}")
+      sc.send(msg, klass.new(basic_name, basic_type, basic.options))
+    end
+  end
+
+  include ::SPQR::Util
+  
+  # turns an instance of a managed object into a QmfObject
+  def qmfify(obj)
+    @log.debug("trying to qmfify #{obj}:  qmf_oid is #{obj.qmf_oid} and class_id is #{obj.class.class_id}")
+    cm = @classes_by_name[obj.class.spqr_meta.classname.to_s]
+    return nil unless cm
+
+    qmfobj = Qmf::AgentObject.new(cm.schema_class)
+
+    set_attrs(qmfobj, obj)
+
+    @log.debug("calling alloc_object_id(#{obj.qmf_oid}, #{obj.class.class_id})")
+    oid = @agent.alloc_object_id(obj.qmf_oid, obj.class.class_id)
+    
+    @log.debug("calling qmfobj.set_object_id(#{oid})")
+    qmfobj.set_object_id(oid)
+    
+    @log.debug("returning from qmfify")
+    qmfobj
+  end
+
+  def set_attrs(qo, o)
+    return unless o.class.respond_to? :spqr_meta
+    
+    attrs = o.class.spqr_meta.properties + o.class.spqr_meta.statistics
+
+    attrs.each do |a|
+      getter = a.name.to_s
+      @log.debug("setting property/statistic #{getter} to its value from #{o}: #{o.send(getter) if o.respond_to?(getter)}")
+      value = o.send(getter) if o.respond_to?(getter)
+
+      if value || a.kind == :bool
+        # XXX: remove this line when/if Manageable includes an
+        # appropriate impl method
+        value = encode_object(value) if value.kind_of?(::SPQR::Manageable)
+        qo[getter] = value
+      end
+
+    end
+  end
+end

metadata

@@ -1,12 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: spqr
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 3
-  - 1
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors: 
 - William Benton
@@ -14,23 +9,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-29 00:00:00 -05:00
+date: 2010-09-15 00:00:00 -05:00
 default_executable: spqr-gen.rb
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 2
-        - 9
         version: 1.2.9
-  type: :development
-  version_requirements: *id001
+    version: 
 description: SPQR makes it very simple to expose methods on Ruby objects over QMF.  You must install ruby-qmf in order to use SPQR.
 email: willb@redhat.com
 executables: 
@@ -92,20 +83,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
+  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
+  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: "SPQR:  {Schema Processor|Straightforward Publishing} for QMF agents in Ruby"
@@ -120,11 +109,11 @@ test_files:
 - test/helper.rb
 - test/test_failbot.rb
 - test/test_spqr_boolprop.rb
+- test/standalone-test.rb
 - test/test_spqr_clicker.rb
 - test/test_spqr_integerprop.rb
 - test/test_user_and_context.rb
 - test/test_spqr_hello.rb
 - examples/logdaemon.rb
 - examples/hello.rb
-- examples/codegen/EchoAgent.rb
 - examples/logservice.rb

data/examples/codegen/EchoAgent.rb

@@ -1,33 +0,0 @@
-module Examples
-  module Codegen
-    class EchoAgent
-      include SPQR::Manageable
-      
-      spqr_package 'examples.codegen'
-      spqr_class 'EchoAgent'
-      # Find method (NB:  you must implement this)
-      def EchoAgent.find_by_id(objid)
-        EchoAgent.new
-      end
-      # Find-all method (NB:  you must implement this)
-      def EchoAgent.find_all
-        [EchoAgent.new]
-      end
-      ### Schema method declarations
-      
-      # echo returns its argument
-      # * arg (lstr/IO)
-      # 
-      def echo(args)
-        # Print values of in/out parameters
-        log.debug "arg => #{args["arg"]}" # 
-        # Assign values to in/out parameters
-        args["arg"] = args["arg"]
-      end
-      
-      spqr_expose :echo do |args|
-        args.declare :arg, :lstr, :inout, {}
-      end
-    end
-  end
-end