spqr 0.0.1

data/lib/spqr/app.rb

@@ -0,0 +1,299 @@
+# SPQR:  Schema Processor for QMF/Ruby agents
+#
+# Application skeleton class
+#
+# Copyright (c) 2009 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
+
+require 'spqr/spqr'
+require 'qmf'
+require 'logger'
+
+module SPQR
+  class App < Qmf::AgentHandler
+    class ClassMeta < Struct.new(:object_class, :schema_class) ; end
+
+    def initialize(options=nil)
+      defaults = {:logfile=>STDERR, :loglevel=>Logger::WARN}
+      
+      # 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]]
+
+      @log = Logger.new(options[:logfile])
+      @log.level = options[:loglevel]
+
+      @log.info("initializing SPQR app....")
+
+      @classes_by_name = {}
+      @classes_by_id = {}
+    end
+
+    def register(*ks)
+      manageable_ks = ks.select {|kl| manageable? kl}
+      unmanageable_ks = ks.select {|kl| not manageable? kl}
+      manageable_ks.each do |klass|
+        @log.info("SPQR will manage registered class #{klass} (#{klass.name})...")
+        
+        schemaclass = schematize(klass)
+
+        klass.spqr_logger = @log
+
+        @classes_by_id[klass.class_id] = klass
+        @classes_by_name[klass.name] = ClassMeta.new(klass, schemaclass)
+      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
+        class_id = obj_id.object_num_high
+        obj_id = obj_id.object_num_low
+
+        @log.debug "calling method: context=#{context} method=#{name} object_id=#{obj_id}, args=#{args}, user=#{user_id}"
+
+        # Turn the Qmf::Arguments structure into a proper ruby hash
+
+        # XXX: consider adding appropriate impl method to Manageable
+        # to avoid this little dance
+        hash_args = qmf_arguments_to_hash(args)
+
+        managed_object = find_object(context, class_id, obj_id)
+        @log.debug("managed object is #{managed_object}")
+
+        @log.debug("managed_object.respond_to? #{name.to_sym} ==> #{managed_object.respond_to? name.to_sym}")
+        managed_object.send(name.to_sym, hash_args)
+        
+        # Copy any out parameters from hash_args from the
+        # Qmf::Arguments structure; see XXX above
+        hash_args.each do |k,v|
+          encoded_val = encode_object(v)
+          args[k] = encoded_val
+        end
+
+        @agent.method_response(context, 0, "OK", 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}"
+
+      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
+      # XXX:  fix and parameterize as necessary
+      @log.debug("starting SPQR::App.main...")
+      
+      settings = Qmf::ConnectionSettings.new
+      settings.host = 'localhost'
+      
+      @connection = Qmf::Connection.new(settings)
+      @log.debug(" +-- @connection created:  #{@connection}")
+
+      @agent = Qmf::Agent.new(self)
+      @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 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
+      klass = @classes_by_id[c_id]
+      klass.find_by_id(obj_id) if klass
+    end
+    
+    def schematize(klass)
+      @log.info("Making a QMF schema for #{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.mmethods.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}")
+          
+          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))
+        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
+
+    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
+
+    # 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.name]
+      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
+          # 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
+end

data/lib/spqr/codegen.rb

@@ -0,0 +1,434 @@
+# Code generation for SPQR
+#
+# Copyright (c) 2009 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
+
+require 'spqr/spqr'
+
+require 'rexml/document'
+require 'fileutils'
+require 'optparse'
+
+module SPQR
+
+  class SchemaClass
+    attr_accessor :name, :package
+
+    def self.declare(name, package)
+      kl = SchemaClass.new(name, package)
+      yield kl if block_given?
+      kl
+    end
+
+    def declare_property(name, kind, options)
+      declare_basic(:property, name, kind, options)
+    end
+
+    def declare_statistic(name, kind, options)
+      declare_basic(:statistic, name, kind, options)
+    end
+
+    def declare_method(name, desc, options)
+      result = SchemaMethod.new name, desc, options.dup
+
+      yield result.args if block_given?
+      @methods << result
+      @methods[-1]
+    end
+
+    def initialize(nm=nil, pkg=nil)
+      @name, @package = nm, pkg
+      @properties = []
+      @statistics = []
+      @methods = []
+    end
+
+    def with_each(what)
+      source = self.instance_variable_get("@#{what}".to_sym) || []
+      source.each do |x|
+        yield x if block_given?
+      end
+    end
+
+    def member_count(what)
+      source = self.instance_variable_get("@#{what}".to_sym) || []
+      source.size
+    end
+
+    private
+    def declare_basic(what, name, kind, options)
+      @wherelocs ||= {:property=>@properties,:statistic=>@statistics}
+      where = @wherelocs[what]
+
+      opts = options.dup
+      opts[:index] = true if opts[:index]
+      desc = opts.delete(:desc)
+
+      where << SchemaBasic.new(what, name, desc, kind, opts)
+      where[-1]
+    end
+
+    class SchemaBasic
+      attr_accessor :name, :kind, :desc, :options
+      def initialize(what,nm,desc,knd,opts)
+        @what = what
+        @name = nm
+        @kind = knd
+        @options = opts
+        @desc = desc.gsub(/\s+/, " ") if desc
+      end
+
+      def property?
+        @what == :property
+      end
+
+      def statistic?
+        @what == :statistic
+      end
+    end
+
+    class SchemaMethod
+      attr_accessor :name, :desc, :options, :args
+      def initialize(nm,desc,opts=nil)
+        @options = (opts && opts.dup) || {}
+        @name = nm
+        @desc = desc.gsub(/\s+/, " ") if desc
+        @args = arg_struct
+      end
+
+      private
+      def arg_struct
+        @@prototype_args ||= gen_prototype_args
+        @@prototype_args.clone
+      end
+
+      def gen_prototype_args
+        prototype_args = []
+
+        def prototype_args.declare(name, kind, dir, desc, options)
+          opts = options.dup
+
+          self << ::SPQR::SchemaClass::SchemaArg.new(name, kind, dir, desc, opts)
+        end
+
+        prototype_args
+      end
+    end
+
+    class SchemaArg
+      attr_accessor :name, :desc, :kind, :dir, :options
+      def initialize(nm, knd, dr, dsc, opts)
+        @name = nm
+        @desc = dsc.gsub(/\s+/, " ") if dsc
+        @kind = knd
+        @dir = dr
+        @options = opts
+      end
+
+      def inspect
+        [:name, :desc, :kind, :dir, :options].map { |sel|"[#{sel}:#{self.send(sel)}]" }.join(" ")
+      end
+    end
+  end
+
+
+  class ModelClassGenerator
+    include ::SPQR::PrettyPrinter
+
+    def ModelClassGenerator.id_registry
+      @id_registry ||= {}
+    end
+
+    def ModelClassGenerator.class_registry
+      @class_registry ||= {}
+    end
+
+    def initialize(sc)
+      @sc = sc
+    end
+
+    def gen
+      @package_list = @sc.package.split(".")
+      package_dir = "./#{@package_list.join('/')}"
+      FileUtils.mkdir_p package_dir
+
+      filename = "#{$OUTDIR}/#{package_dir}/#{@sc.name}.rb"
+      with_output_to filename do
+        gen_class
+      end
+    end
+
+    private
+    def gen_class
+      pp "require 'spqr/spqr'"
+      pp ""
+      
+      @package_list.map {|pkg| pkg.capitalize}.each do |modname|
+        pp "module #{modname}"
+        inc_indent
+      end
+
+      pp_decl :class, @sc.name do
+        pkgname = (@package_list.map {|pkg| pkg.capitalize}).join("::")
+        fqcn = ("#{pkgname}::#{@sc.name}" if pkgname) or @sc.name
+
+        pp "include ::SPQR::Manageable"
+        pp ""
+
+        pp "spqr_package '#{@package_list.join(".")}'"
+        pp "spqr_class '#{@sc.name.split("::")[-1]}'"
+
+        pp '# Find method (NB:  you must implement this)'
+        pp_decl :def, "#{@sc.name}.find_by_id", "(objid)" do
+          pp "#{@sc.name}.new"
+        end
+
+        pp "\n# Find-all method (NB:  you must implement this)"
+        pp_decl :def, "#{@sc.name}.find_all" do
+          pp "[#{@sc.name}.new]"
+        end
+
+        ModelClassGenerator.id_registry[fqcn.hash] = fqcn
+        ModelClassGenerator.class_registry[fqcn] = fqcn.hash
+
+        pp "\#\#\# Property method declarations" if @sc.member_count(:properties) > 0
+        @sc.with_each :properties do |property|
+          gen_property property
+        end
+
+        pp "\#\#\# Statistic method declarations" if @sc.member_count(:statistics) > 0
+        @sc.with_each :statistics do |statistic|
+          gen_statistic statistic
+        end
+
+        pp "\#\#\# Schema method declarations"
+        @sc.with_each :methods do |method|
+          gen_method method
+        end
+      end
+
+      @package_list.size.times do
+        dec_indent
+        pp "end"
+      end
+    end
+
+    def gen_property(property)
+      pp ""
+      pp "\# property #{property.name} #{property.kind} #{property.desc}"
+      pp_decl :def, "#{property.name}" do
+        pp "log.debug 'Requested property #{property.name}'"
+        pp "nil"
+      end
+
+      pp ""
+      pp_decl :def, "#{property.name}=", "(val)" do
+        pp "log.debug 'Set property #{property.name} to \#\{val\}'"
+        pp "nil"
+      end
+      
+      property.options[:desc] = property.desc if property.desc
+
+      pp ""
+      pp "spqr_property #{property.name.to_sym.inspect}, #{property.kind.to_sym.inspect}, #{property.options.inspect.gsub(/[{}]/, '')}"
+    end
+
+    def gen_statistic(statistic)
+      pp ""
+      pp "\# statistic #{statistic.name}"
+      pp_decl :def, "#{statistic.name}" do
+        pp "log.debug 'Requested statistic #{statistic.name}'"
+        pp "nil"
+      end
+      
+      statistic.options[:desc] = statistic.desc if statistic.desc
+      
+      pp ""
+      pp "spqr_property #{statistic.name.to_sym.inspect}, #{statistic.kind.to_sym.inspect}, #{statistic.options.inspect.gsub(/[{}]/, '')}"
+    end
+
+    def gen_method(method)
+      pp ""
+      pp "\# #{method.name} #{method.desc}"
+      method.args.each do |arg|
+        pp "\# * #{arg.name} (#{arg.kind}/#{arg.dir})"
+        pp "\# #{arg.desc}"
+      end
+      
+      in_params = method.args.select {|arg| ['in', 'i', 'qmf::dir_in'].include? arg.dir.to_s.downcase }
+      out_params = method.args.select {|arg| ['out', 'o', 'qmf::dir_out'].include? arg.dir.to_s.downcase }
+      inout_params = method.args.select {|arg| ['inout', 'io', 'qmf::dir_inout'].include? arg.dir.to_s.downcase }
+      
+      pp_decl :def, method.name, "(args)" do
+        
+        if in_params.size + inout_params.size > 0  
+          what = "in"
+          
+          if in_params.size > 0 and inout_params.size > 0
+            what << " and in/out"
+          elsif inout_params.size > 0
+            what << "/out"
+          end
+          
+          pp "\# Print values of #{what} parameters"
+          (in_params + inout_params).each do |arg|
+            argdisplay = arg.name.to_s.inspect
+            pp('log.debug "' + "#{arg.name} => " + '#{args[' + "#{argdisplay}" + ']}"' + " \# #{}")
+          end
+        end
+
+        if out_params.size + inout_params.size > 0
+          what = "out"
+
+          if out_params.size > 0 and inout_params.size > 0
+            what << " and in/out"
+          elsif inout_params.size > 0
+            what = "in/out"
+          end
+
+          pp "\# Assign values to #{what} parameters"
+
+          (out_params + inout_params).each do |arg|
+            argdisplay = arg.name.to_s.inspect
+            pp "args[#{argdisplay}] = args[#{argdisplay}]"
+          end
+        end
+      end
+
+
+      pp ""
+      pp_decl :spqr_expose, "#{method.name.to_sym.inspect} do |args|" do
+        {:in => in_params, :inout => inout_params, :out => out_params}.each do |dir,coll|
+          coll.each do |arg|
+            arg_nm = arg.name
+            arg_kd = arg.kind
+            arg_opts = arg.options.inspect.gsub(/^[{](.+)[}]$/, '\1')
+            pp "args.declare :#{arg_nm}, :#{arg_kd}, :#{dir}, #{arg_opts}"
+          end
+        end
+      end
+    end
+  end
+
+  class AppBoilerplateGenerator
+    include PrettyPrinter
+
+    # scs is a list of schemaclass objects, fn is an output filename
+    def initialize(scs, fn)
+      @scs = scs
+      @fn = fn
+    end
+
+    # cc is the name of the variable that will hold a collection of schema classes
+    def gen
+      with_output_to @fn do
+        pp "require 'rubygems'"
+        pp "require 'spqr/spqr'"
+        pp "require 'spqr/app'"
+
+        pp ""
+
+        @scs.each do |sc|
+          pp("require '#{sc.package.gsub(/[.]/, '/')}/#{sc.name}'")
+        end
+
+        
+        pp ""
+        
+        pp "app = SPQR::App.new(:loglevel => :debug)"
+        
+        klass_list = @scs.collect do |sc|
+          (sc.package.split(".").collect{|pkg| pkg.capitalize} << sc.name).join("::")
+        end
+        
+        pp "app.register #{klass_list.join ','}"
+        
+        pp ""
+
+        pp "app.main"
+      end
+    end  
+  end
+
+  class QmfSchemaProcessor
+    include ::SPQR::MiscUtil
+    def initialize(fn)
+      @package = nil
+      @file = fn
+      @doc = nil
+      @indent = 0
+      @schema_classes = []
+    end
+
+    def main
+      File::open(@file, "r") {|infile| @doc = REXML::Document.new(infile)}
+
+      process_schema
+      @schema_classes.each do |klass|
+        ModelClassGenerator.new(klass).gen
+      end
+
+      AppBoilerplateGenerator.new(@schema_classes, "#{$OUTDIR}/agent-app.rb").gen
+    end
+
+    private
+
+    def process_schema
+      @package = @doc.root.attributes["package"]
+      @package_list = @package.split(".")
+
+      @package_dir = "#{$OUTDIR}/#{@package_list.join('/')}"
+
+      FileUtils.mkdir_p @package_dir
+
+      REXML::XPath.each(@doc.root, "/schema/class") do |elt|
+        @schema_classes << process_class(elt)
+      end
+    end
+
+    def process_class(elt)
+      classname = "#{elt.attributes['name']}"
+
+      SchemaClass.declare classname, @package do |klass|      
+        REXML::XPath.each(elt, "property") do |property|
+          name = property.attributes['name']
+          kind = property.attributes['type']
+          opts = symbolize_dict(property.attributes, [:desc, :index, :access, :optional, :min, :max, :maxlen, :unit])
+          opts[:index] = (opts[:index].to_s == '1' or opts[:index].to_s.downcase == 'y')
+          klass.declare_property name, kind, opts
+        end
+
+        REXML::XPath.each(elt, "statistic") do |statistic|
+          name = statistic.attributes['name']
+          kind = statistic.attributes['type']
+          opts = symbolize_dict(statistic.attributes, [:desc, :unit])
+          klass.declare_statistic name, kind, {}
+        end
+
+        REXML::XPath.each(elt, "method") do |method|
+          name = method.attributes['name']
+          desc = method.attributes['desc']
+          klass.declare_method name, desc, {} do |args|
+            REXML::XPath.each(method, "arg") do |arg|
+              opts = symbolize_dict(arg.attributes, [:name, :type, :refPackage, :refClass, :dir, :unit, :min, :max, :maxlen, :desc, :default, :references])
+              name = opts.delete(:name)
+              kind = opts.delete(:type)
+              dir = opts.delete(:dir)
+              desc = opts.delete(:desc)
+              args.declare(name, kind, dir, desc, opts)
+            end
+          end
+        end
+
+        klass
+      end
+    end
+  end
+end