spqr 0.2.4 → 0.3.0

data/CHANGES

@@ -1,13 +1,22 @@
-version 0.2.4
+version 0.3.0 (04c1eb70855b6382925c65f350fbb69e9eb58c88)
+
+*  first-class QMF event support via the SPQR::Raiseable mixin.
+*  several small fixes to QMF interoperability (thanks to Ken Giusti 
+   for observations and help)
+*  the current QMF user and context are available to SPQR methods 
+   via Manageable#qmf_user_id and Manageable#qmf_context methods.
+*  various usability improvements to the test suite
+
+version 0.2.4 (f2159d62949e5ed0f0e853bcef28dc4a7e986e48)
 
 *  Workaround for a crash in qmfengine when running on 32-bit machines
 
-version 0.2.3
+version 0.2.3 (ed9a92d249156b57f9d788047f3250b27811fbc8)
 
 *  Fixed a crash that occurred sometimes when attempting to return a 
    value from a failing method.
 
-version 0.2.2
+version 0.2.2 (d6b77f3ca349fe2c9221db5cb796bed1268982e5)
 
 *  Methods on manageable objects now can call fail(status, message) to 
    signal failure in the QMF method response.

data/VERSION

@@ -1 +1 @@
-0.2.4
+0.3.0

data/lib/spqr/app.rb

@@ -45,6 +45,7 @@ module SPQR
 
       @log.info("initializing SPQR app....")
 
+      @event_classes = []
       @classes_by_name = {}
       @classes_by_id = {}
       @pipe = options[:notifier]
@@ -71,11 +72,17 @@ module SPQR
 
         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?"
+          @event_classes << klass
+        end
+
         @log.info("SETTING #{klass.spqr_meta.classname}.app to #{self.inspect}")
-        klass.app = self
-        
-        @classes_by_id[klass.class_id] = klass
-        @classes_by_name[klass.spqr_meta.classname.to_s] = ClassMeta.new(klass, schemaclass)
+        klass.app = self        
       end
       
       unmanageable_ks.each do |klass|
@@ -93,6 +100,9 @@ module SPQR
         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)
@@ -204,16 +214,25 @@ module SPQR
 
       @agent = Qmf::Agent.new(self, @app_name)
       @log.debug(" +-- @agent created:  #{@agent}")
+      
+      object_class_count = @classes_by_name.size
+      event_class_count = @event_classes.size
 
-      @agent.set_connection(@connection)
-      @log.debug(" +-- @agent.set_connection called")
-
-      @log.debug(" +-- registering classes...")
-      @classes_by_name.values.each do |km| 
+      @log.info(" +-- registering #{object_class_count} object #{pluralize(object_class_count, "class", "classes")} and #{event_class_count} event #{pluralize(event_class_count, "class", "classes")}....")
+      
+      all_schemas = @classes_by_name.values + @event_classes
+      
+      all_schemas.each do |km|
+        identifier = ("object #{km.schema_class.package_name}.#{km.schema_class.class_name}" rescue "#{km.class.to_s}")
+        
+        @log.debug(" +--+-- TRYING to register #{identifier}")
         @agent.register_class(km.schema_class) 
-        @log.debug(" +--+-- #{km.schema_class.package_name} #{km.schema_class.class_name} registered")
+        @log.info(" +--+-- #{identifier} REGISTERED")
       end
       
+      @agent.set_connection(@connection)
+      @log.debug(" +-- @agent.set_connection called")
+
       @log.debug("entering orbit....")
 
       sleep
@@ -221,6 +240,11 @@ module SPQR
 
     private
     
+    def pluralize(count, singular, plural=nil)
+      plural ||= "#{singular}s"
+      count == 1 ? singular : plural
+    end
+    
     def result_valid(actuals, mm)
       (actuals.kind_of?(Array) and mm.formals_out.size == actuals.size) or mm.formals_out.size <= 1
     end
@@ -249,6 +273,16 @@ module SPQR
     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
@@ -266,19 +300,7 @@ module SPQR
         mm.args.each do |arg| 
           @log.info("| +-- creating a QMF schema for arg #{arg}")
           
-          arg_opts = arg.options
-          arg_opts[:desc] ||= arg.description if (arg.description and arg.description.is_a? String)
-          arg_opts[:dir] ||= get_xml_constant(arg.direction.to_s, ::SPQR::XmlConstants::Direction)
-          arg_name = arg.name.to_s
-          arg_type = get_xml_constant(arg.kind.to_s, ::SPQR::XmlConstants::Type)
-          
-          if @log.level <= Logger::DEBUG
-            local_variables.grep(/^arg_/).each do |local|
-              @log.debug("      #{local} --> #{(eval local).inspect}")
-            end
-          end
-
-          method.add_argument(Qmf::SchemaArgument.new(arg_name, arg_type, arg_opts))
+          encode_argument(arg, method)
         end
 
         sc.add_method(method)
@@ -300,36 +322,8 @@ module SPQR
       end
     end
 
-    def manageable?(k)
-      # FIXME:  move out of App, into Manageable or a related utils module?
-      k.is_a? Class and k.included_modules.include? ::SPQR::Manageable
-    end
-
-    def get_xml_constant(xml_key, dictionary)
-      # FIXME:  move out of App, into a utils module?
-      string_val = dictionary[xml_key]
-      return xml_key unless string_val
-
-      actual_val = const_lookup(string_val)
-      return string_val unless actual_val
-
-      return actual_val
-    end
-
-    # turns a string name of a constant into the value of that
-    # constant; returns that value, or nil if fqcn doesn't correspond
-    # to a valid constant
-    def const_lookup(fqcn)
-      # FIXME:  move out of App, into a utils module?
-      hierarchy = fqcn.split("::")
-      const = hierarchy.pop
-      mod = Kernel
-      hierarchy.each do |m|
-        mod = mod.const_get(m)
-      end
-      mod.const_get(const) rescue nil
-    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}")

data/lib/spqr/codegen.rb

@@ -399,7 +399,7 @@ module SPQR
   end
 
   class QmfSchemaProcessor
-    include ::SPQR::MiscUtil
+    include ::SPQR::Util
     def initialize(fn)
       @package = nil
       @file = fn

data/lib/spqr/constants.rb

@@ -59,6 +59,17 @@ module SPQR
       "out" => 'Qmf::DIR_OUT',
       "inout" => 'Qmf::DIR_IN_OUT'
     }
+    
+    Severity = {
+      "emerg" => "Qmf::SEV_EMERG", 
+      "error" => "Qmf::SEV_ERROR", 
+      "notice" => "Qmf::SEV_NOTICE", 
+      "crit" => "Qmf::SEV_CRIT", 
+      "debug" => "Qmf::SEV_DEBUG", 
+      "inform" => "Qmf::SEV_INFORM", 
+      "alert" => "Qmf::SEV_ALERT", 
+      "warn" => "Qmf::SEV_WARN"
+    }
   end
 
 end

data/lib/spqr/event.rb

@@ -0,0 +1,159 @@
+# SPQR:  Schema Processor for QMF/Ruby agents
+#
+# Manageable object mixin and support classes.
+#
+# Copyright (c) 2009--2010 Red Hat, Inc.
+#
+# Author:  William Benton (willb@redhat.com)
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+module SPQR
+  class EventMeta < Struct.new(:package, :classname, :args, :severity)
+    def initialize(*a)
+      super *a
+      self.args ||= []
+      self.severity ||= :alert
+    end
+  end
+
+  class EventArgMeta < Struct.new(:name, :kind, :description, :options)
+    def initialize(*a)
+      super *a
+      self.options = ((!self.options && {}) || self.options.dup)
+    end
+  end
+  
+  module Raiseable
+    module ClassMixins
+      include ::SPQR::Util
+      
+      def arg(name, kind, description=nil, options=nil)
+        @spqr_event_meta ||= EventMeta.new
+        @spqr_event_meta.args << EventArgMeta.new(name.to_sym,kind,description,options)
+        attr_accessor name.to_sym
+        attr_setters << "#{name.to_s}="
+      end
+      
+      def spqr_meta
+        @spqr_event_meta ||= EventMeta.new
+        
+      end
+      
+      def log=(logger)
+        @spqr_log = logger
+      end
+
+      def log
+        @spqr_log || ::SPQR::Sink.new
+      end
+
+      def app=(app)
+        @spqr_app = app
+      end
+
+      def app
+        @spqr_app
+      end
+      
+      def attr_setters
+        @attr_setters ||= []
+        @attr_setters
+      end
+      
+      def schematize
+        severity = get_xml_constant(spqr_meta.severity.to_s, ::SPQR::XmlConstants::Severity)
+        
+        @spqr_schema_class = Qmf::SchemaEventClass.new(spqr_meta.package.to_s, spqr_meta.classname.to_s, severity)
+        
+        spqr_meta.args.each do |arg|
+          encode_argument(arg, @spqr_schema_class)
+        end
+        
+        @spqr_schema_class
+      end
+      
+      def schema_class
+        @spqr_schema_class
+      end
+      
+      def qmf_package_name(nm)
+        spqr_meta.package = nm
+      end
+
+      def qmf_class_name(nm)
+        spqr_meta.classname = nm
+      end
+      
+      def qmf_severity(sev)
+        raise ArgumentError.new("Invalid event severity '#{sev.inspect}'") unless ::SPQR::XmlConstants::Severity.keys.include? sev.to_s
+        spqr_meta.severity = sev
+      end
+      
+      alias severity qmf_severity
+    end
+    
+    module InstanceMixins
+      def initialize(*args)
+        if args.size > self.class.attr_setters.size
+          msg = "Too many arguments (max #{self.class.attr_setters.size}) to #{self.class.name}#initialize:  #{args}"
+          log.error msg
+          raise ArgumentError.new(msg)
+        end
+        
+        message_pairs = self.class.attr_setters.zip(args).reject {|setter,val| val==nil}
+        message_pairs.each {|message| self.send *message}
+          
+      end
+      
+      def app
+        self.class.app
+      end
+      
+      def schema_class
+        self.class.schema_class
+      end
+      
+      def log
+        self.class.log
+      end
+      
+      def bang!
+        unless schema_class
+          log.fatal("No schema class defined for SPQR event class #{self.class.name}; will not raise event.  Did you register this event class?")
+          return
+        end
+        
+        log.info("Raising an event of class #{self.class.name}")
+        
+        event = Qmf::QmfEvent.new(schema_class)
+        log.debug "Created QmfEvent is #{event.inspect}"
+        
+        self.class.spqr_meta.args.each do |arg|
+          val = self.send arg.name
+          log.debug "setting #{arg.name} of event to #{val}"
+          event.send "#{arg.name}=", val
+        end
+        
+        log.debug "event to raise is #{event.inspect} (#{event})"
+        log.debug "arguments are #{event.arguments.inspect} (#{event.arguments})"
+
+        
+        app.agent.raise_event(event)
+      end
+    end
+        
+    def self.included(receiver)
+      receiver.extend ClassMixins
+      receiver.send :include, InstanceMixins
+      
+      name_components = receiver.name.to_s.split("::")
+      receiver.qmf_class_name name_components.pop
+      receiver.qmf_package_name name_components.join(".").downcase
+    end
+  end
+end

data/lib/spqr/manageable.rb

@@ -245,6 +245,16 @@ module SPQR
       raise ManageableObjectError.new(*args)
     end
     
+    # Returns the user ID of the QMF user invoking this method
+    def qmf_user_id
+      Thread.current[:qmf_user_id]
+    end
+
+    # Returns QMF context of the current method invocation
+    def qmf_context
+      Thread.current[:qmf_context]
+    end
+
     def qmf_oid
       result = 0
       if self.respond_to? :spqr_object_id 

data/lib/spqr/spqr.rb

@@ -14,3 +14,4 @@ require 'spqr/utils'
 require 'spqr/constants'
 require 'spqr/codegen'
 require 'spqr/manageable'
+require 'spqr/event'

data/lib/spqr/utils.rb

@@ -72,17 +72,56 @@ module SPQR
       end
     end
   end
-
-  module MiscUtil
+  
+  module Util
     def symbolize_dict(k, kz=nil)
       k2 = {}
       kz ||= k.keys
 
       k.keys.each do |key|
-        k2[key.to_sym] = k[key] if (kz.include?(key) or kz.include?(key.to_sym))
+        k2[key.to_sym] = k[key] if (kz.include?(key) || kz.include?(key.to_sym))
       end
 
       k2
     end
+    
+    def get_xml_constant(xml_key, dictionary)
+      string_val = dictionary[xml_key]
+      return xml_key unless string_val
+
+      actual_val = const_lookup(string_val)
+      return string_val unless actual_val
+
+      return actual_val
+    end
+    
+    # turns a string name of a constant into the value of that
+    # constant; returns that value, or nil if fqcn doesn't correspond
+    # to a valid constant
+    def const_lookup(fqcn)
+      # FIXME:  move out of App, into a utils module?
+      hierarchy = fqcn.split("::")
+      const = hierarchy.pop
+      mod = Kernel
+      hierarchy.each do |m|
+        mod = mod.const_get(m)
+      end
+      mod.const_get(const) rescue nil
+    end
+    
+    def encode_argument(arg, destination)
+      arg_opts = arg.options
+      arg_opts[:desc] ||= arg.description if (arg.description && arg.description.is_a?(String))
+      arg_opts[:dir] ||= get_xml_constant(arg.direction.to_s, ::SPQR::XmlConstants::Direction) if arg.respond_to? :direction
+      arg_name = arg.name.to_s
+      arg_type = get_xml_constant(arg.kind.to_s, ::SPQR::XmlConstants::Type)
+
+      destination.add_argument(Qmf::SchemaArgument.new(arg_name, arg_type, arg_opts))
+    end
+    
+    def manageable?(k)
+      k.is_a?(Class) && (k.included_modules.include?(::SPQR::Manageable) || k.included_modules.include?(::SPQR::Raiseable))
+    end
+    
   end
 end

data/ruby-spqr.spec.in

@@ -41,6 +41,7 @@ mkdir -p %{buildroot}/%{ruby_sitelib}/spqr
 cp -f lib/spqr/app.rb %{buildroot}/%{ruby_sitelib}/spqr
 cp -f lib/spqr/codegen.rb %{buildroot}/%{ruby_sitelib}/spqr
 cp -f lib/spqr/constants.rb %{buildroot}/%{ruby_sitelib}/spqr
+cp -f lib/spqr/event.rb %{buildroot}/%{ruby_sitelib}/spqr
 cp -f lib/spqr/manageable.rb %{buildroot}/%{ruby_sitelib}/spqr
 cp -f lib/spqr/spqr.rb %{buildroot}/%{ruby_sitelib}/spqr
 cp -f lib/spqr/utils.rb %{buildroot}/%{ruby_sitelib}/spqr
@@ -56,6 +57,7 @@ rm -rf %{buildroot}
 %{ruby_sitelib}/spqr/app.rb
 %{ruby_sitelib}/spqr/codegen.rb
 %{ruby_sitelib}/spqr/constants.rb
+%{ruby_sitelib}/spqr/event.rb
 %{ruby_sitelib}/spqr/manageable.rb
 %{ruby_sitelib}/spqr/spqr.rb
 %{ruby_sitelib}/spqr/utils.rb
@@ -68,6 +70,9 @@ rm -rf %{buildroot}
 
 %changelog
 
+* Mon May 10 2010  <willb@redhat> - 0.3.0-1
+- updated to version 0.3.0-1
+
 * Mon Apr 12 2010  <willb@redhat> - 0.2.4-1
 - updated to version 0.2.4-1
 

data/test/example-apps.rb

@@ -1,3 +1,25 @@
+class QmfUserAndContext
+  include ::SPQR::Manageable
+
+  def QmfUserAndContext.find_by_id(oid)
+    @singleton ||= QmfUserAndContext.new
+    @singleton
+  end
+  
+  def QmfUserAndContext.find_all
+    @singleton ||= QmfUserAndContext.new
+    [@singleton]
+  end
+
+  expose :qmf_user_id do |args|
+    args.declare :uid, :sstr, :out
+  end
+
+  expose :qmf_context do |args|
+    args.declare :ctx, :uint64, :out
+  end
+end
+
 class QmfClicker
   include ::SPQR::Manageable
   
@@ -233,3 +255,90 @@ class QmfListArg
   qmf_class_name :QmfListArg
   qmf_package_name :example
 end
+
+class DummyEvent
+  include ::SPQR::Raiseable
+  
+  qmf_class_name :DummyEvent
+  qmf_package_name :example
+  qmf_severity :notice
+end
+
+class QmfDummyEventer
+  include ::SPQR::Manageable 
+
+  def qmf_oid
+    1234
+  end
+
+  def spqr_object_id
+    1234
+  end
+ 
+  def QmfDummyEventer.find_by_id(oid)
+    @objs ||= [QmfDummyEventer.new]
+    @objs[0]
+  end
+  
+  def QmfDummyEventer.find_all
+    @objs ||= [QmfDummyEventer.new]
+    @objs
+  end
+  
+  def party_on
+    DummyEvent.new.bang!
+  end
+
+  expose :party_on do |args|
+  end
+  
+  qmf_class_name :QmfDummyEventer
+  qmf_package_name :example
+end
+
+
+class ArgEvent
+  include ::SPQR::Raiseable
+  
+  arg :arg, :map, "A map from the name of the party_on method to the first count even numbers"
+  
+  qmf_class_name :ArgEvent
+  qmf_package_name :example
+  qmf_severity :notice
+end
+
+class QmfArgEventer
+  include ::SPQR::Manageable 
+
+  def qmf_oid
+    1234
+  end
+
+  def spqr_object_id
+    1234
+  end
+ 
+  def QmfArgEventer.find_by_id(oid)
+    @objs ||= [QmfArgEventer.new]
+    @objs[0]
+  end
+  
+  def QmfArgEventer.find_all
+    @objs ||= [QmfArgEventer.new]
+    @objs
+  end
+  
+  def party_on_one(name, count)
+    ls = (1..count).to_a.map {|x| x*2}
+#    ArgEvent.new({name=>ls}).bang!
+    ArgEvent.new({name=>count}).bang!
+  end
+
+  expose :party_on_one do |args|
+    args.declare :name, :sstr, :in
+    args.declare :count, :uint64, :in
+  end
+  
+  qmf_class_name :QmfArgEventer
+  qmf_package_name :example
+end

data/test/helper.rb

@@ -10,22 +10,34 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'spqr/spqr'
 require 'spqr/app'
 
+$QMFENGINE_CONSOLE_SUPPORTS_EVENTS = (::ENV["QMFENGINE_CONSOLE_SUPPORTS_EVENTS"] && ::ENV["QMFENGINE_CONSOLE_SUPPORTS_EVENTS"] == "1")
+
 module QmfTestHelpers
-  DEBUG = (::ENV["SPQR_TESTS_DEBUG"] and ::ENV["SPQR_TESTS_DEBUG"].downcase == "yes")
+  DEBUG = (::ENV["SPQR_TESTS_DEBUG"] && ((::ENV["SPQR_TESTS_DEBUG"].downcase == "yes" && "yes") || (::ENV["SPQR_TESTS_DEBUG"].downcase == "trace" && "trace")))
   
   class AgentNotifyHandler < Qmf::ConsoleHandler
     def initialize
       @q = Queue.new
+      @eq = Queue.new
     end
     
     def queue
       @q
     end
+    
+    def event_queue
+      @eq
+    end
 
     def agent_added(agent)
       puts "GOT AN AGENT:  #{agent} at #{Time.now.utc}" if DEBUG
       @q << agent
     end
+    
+    def event_received(event)
+      puts "GOT AN EVENT:  #{event} at #{Time.now.utc}"
+      @eq << event
+    end
   end
 
   def app_setup(*classes)
@@ -47,14 +59,14 @@ module QmfTestHelpers
         $stdout.reopen("/dev/null", "w")
         $stderr.reopen("/dev/null", "w")
       else
-        ENV['QPID_TRACE'] = "1"
+        ENV['QPID_TRACE'] = "1" if DEBUG == "trace"
       end
 
       exec("#{File.dirname(__FILE__)}/generic-agent.rb", *classes.map {|cl| cl.to_s})
       exit! 127
 
       @app = SPQR::App.new(:loglevel => (DEBUG ? :debug : :fatal), :appname=>"#{classes.join("")}[#{Process.pid}]")
-      @app.register *classes
+      @app.register(*classes)
 
       @app.main
     end

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

data/test/test_events.rb

@@ -0,0 +1,45 @@
+require 'helper'
+require 'set'
+require 'example-apps'
+
+class TestEvents < Test::Unit::TestCase
+  include QmfTestHelpers
+
+  def setup
+    @child_pid = nil
+    $notify_handler.event_queue.clear if $notify_handler
+  end
+
+  def test_dummy_event
+    app_setup DummyEvent, QmfDummyEventer
+    de = $console.object(:class=>"QmfDummyEventer", :agent=>@ag)
+    method_response = de.party_on
+    assert_equal 0, method_response.status
+    
+    sleep 2
+
+    if $QMFENGINE_CONSOLE_SUPPORTS_EVENTS
+      ev = Timeout::timeout(5) do
+        $notify_handler.event_queue.pop
+      end
+
+      # XXX:  make an appropriate assertion about ev here
+    end
+  end
+
+  def test_arg_event
+    app_setup ArgEvent, QmfArgEventer
+    de = $console.object(:class=>"QmfArgEventer", :agent=>@ag)
+    method_response = de.party_on_one("foobar", 5)
+    assert_equal 0, method_response.status
+    sleep 2
+
+    if $QMFENGINE_CONSOLE_SUPPORTS_EVENTS
+      ev = Timeout::timeout(5) do
+        $notify_handler.event_queue.pop
+      end
+
+      # XXX:  make an appropriate assertion about ev here
+    end
+  end
+end

data/test/test_user_and_context.rb

@@ -0,0 +1,31 @@
+require 'helper'
+require 'set'
+require 'example-apps'
+
+class TestUserAndContext < Test::Unit::TestCase
+  include QmfTestHelpers
+
+  def setup
+    @child_pid = nil
+  end
+
+  def test_user_id
+    app_setup QmfUserAndContext
+
+    uac = $console.object(:class=>"QmfUserAndContext", :agent=>@ag)
+    userid = uac.qmf_user_id.uid
+    assert_equal(::ENV['SPQR_TESTS_QMF_USER_ID'] || "anonymous", userid)
+  end
+
+  def test_context
+    app_setup QmfUserAndContext
+
+    uac = $console.object(:class=>"QmfUserAndContext", :agent=>@ag)
+    ctx = uac.qmf_context.ctx
+
+    9.times do 
+      old_ctx = ctx
+      assert(old_ctx < uac.qmf_context.ctx)
+    end
+  end
+end

metadata

@@ -1,12 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: spqr
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 2
-  - 4
-  version: 0.2.4
+  version: 0.3.0
 platform: ruby
 authors: 
 - William Benton
@@ -14,23 +9,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-12 00:00:00 -05:00
+date: 2010-05-10 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: 
@@ -57,6 +48,7 @@ files:
 - lib/spqr/app.rb
 - lib/spqr/codegen.rb
 - lib/spqr/constants.rb
+- lib/spqr/event.rb
 - lib/spqr/manageable.rb
 - lib/spqr/spqr.rb
 - lib/spqr/utils.rb
@@ -68,6 +60,7 @@ files:
 - test/example-apps.rb
 - test/generic-agent.rb
 - test/helper.rb
+- test/test_events.rb
 - test/test_failbot.rb
 - test/test_spqr_boolprop.rb
 - test/test_spqr_clicker.rb
@@ -75,6 +68,7 @@ files:
 - test/test_spqr_hello.rb
 - test/test_spqr_integerprop.rb
 - test/test_spqr_listarg.rb
+- test/test_user_and_context.rb
 has_rdoc: true
 homepage: http://git.fedorahosted.org/git/grid/spqr.git
 licenses: []
@@ -88,20 +82,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"
@@ -112,12 +104,14 @@ test_files:
 - test/test_spqr_dummyprop.rb
 - test/test_spqr_listarg.rb
 - test/generic-agent.rb
+- test/test_events.rb
 - 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/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