spqr 0.3.0 → 0.3.1

data/CHANGES

@@ -1,3 +1,7 @@
+version 0.3.1
+
+*  "qmf_singleton" declaration for boilerplate-free singleton classes
+
 version 0.3.0 (04c1eb70855b6382925c65f350fbb69e9eb58c88)
 
 *  first-class QMF event support via the SPQR::Raiseable mixin.

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.3.1

data/examples/codegen/EchoAgent.rb

@@ -0,0 +1,33 @@
+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

data/examples/logdaemon.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+
+# This is a simple logging service that operates over QMF.  It is very similar
+# to logservice.rb, except it makes QMF events for log events instead of
+# database records.  LogEventService has the same API as LogService; LogEvent
+# is a SPQR event class.  See the comments for details on how to use QMF events.
+
+require 'spqr/spqr'
+require 'spqr/app'
+
+class LogEventService
+  include SPQR::Manageable
+
+  [:debug, :warn, :info, :error].each do |name|
+    define_method name do |msg|
+      # Construct a new event by passing arguments to .new in the order that they were declared
+      ev = LogEvent.new(Time.now.utc.to_i * 1000000000, "#{name.to_s.upcase}", msg.dup)
+      
+      # You can also set arguments of an event object individually, like this:
+      # ev = LogEvent.new
+      # ev.l_when = Time.now
+      # ev.severity = name.to_s.upcase
+      # ev.msg = msg.dup
+      
+      # Once all of the arguments are set, raise the event:
+      ev.bang!
+    end
+    
+    expose name do |args|
+      args.declare :msg, :lstr, :in
+    end
+  end
+
+  def self.find_all
+    @singleton ||= LogEventService.new
+    [@singleton]
+  end
+
+  def self.find_by_id(i)
+    @singleton ||= LogEventService.new
+  end
+
+  qmf_package_name :examples
+  qmf_class_name :LogEventService
+end
+
+class LogEvent
+  # To declare an event class, include SPQR::Raiseable
+  include ::SPQR::Raiseable
+  
+  # Declare arguments with their name, type, and (optional) description
+  arg :l_when, :absTime, "When the event happened"
+  arg :severity, :sstr, "Event severity:  DEBUG, WARN, INFO, or ERROR"
+  arg :msg, :lstr, "Log message"
+
+  # Declare metadata as appropriate
+  qmf_package_name :examples
+  qmf_class_name :LogEvent
+end
+
+app = SPQR::App.new(:loglevel => :debug)
+
+# Event classes must be registered just like object classes
+app.register LogEventService, LogEvent
+
+app.main

data/lib/spqr/manageable.rb

@@ -157,8 +157,22 @@ module SPQR
     # Exposes a method to QMF
     def expose(name, description=nil, options=nil, &blk)
       spqr_meta.declare_method(name, description, options, blk)
-    end      
-    
+    end
+
+    def qmf_singleton
+      def self.instances
+        @instances ||= [self.new]
+      end
+
+      def self.find_all
+        instances
+      end
+
+      def self.find_by_id(id)
+        instances[0]
+      end
+    end
+
     def qmf_package_name(nm)
       spqr_meta.package = nm
     end

data/test/example-apps.rb

@@ -1,15 +1,17 @@
 class QmfUserAndContext
   include ::SPQR::Manageable
 
-  def QmfUserAndContext.find_by_id(oid)
-    @singleton ||= QmfUserAndContext.new
-    @singleton
-  end
+  qmf_singleton
+
+  # def QmfUserAndContext.find_by_id(oid)
+  #   @singleton ||= QmfUserAndContext.new
+  #   @singleton
+  # end
   
-  def QmfUserAndContext.find_all
-    @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

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: spqr
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 1
+  version: 0.3.1
 platform: ruby
 authors: 
 - William Benton
@@ -9,19 +14,23 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-10 00:00:00 -05:00
+date: 2010-05-29 00:00:00 -05:00
 default_executable: spqr-gen.rb
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
         version: 1.2.9
-    version: 
+  type: :development
+  version_requirements: *id001
 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: 
@@ -44,6 +53,7 @@ files:
 - bin/spqr-gen.rb
 - examples/codegen-schema.xml
 - examples/hello.rb
+- examples/logdaemon.rb
 - examples/logservice.rb
 - lib/spqr/app.rb
 - lib/spqr/codegen.rb
@@ -82,18 +92,20 @@ 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.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: "SPQR:  {Schema Processor|Straightforward Publishing} for QMF agents in Ruby"
@@ -108,10 +120,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/test/standalone-test.rb

@@ -1,330 +0,0 @@
-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