spqr 0.3.2 → 0.3.3

data/VERSION

@@ -1 +1 @@
-0.3.2
+0.3.3

data/lib/spqr/app.rb

@@ -18,6 +18,8 @@ require 'logger'
 
 module SPQR
   class App < Qmf::AgentHandler
+    VALID_MECHANISMS = %w{ANONYMOUS PLAIN GSSAPI}
+
     class ClassMeta < Struct.new(:object_class, :schema_class) ; end
 
     attr_reader :agent
@@ -52,12 +54,11 @@ module SPQR
       @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_sendUserId = options.has_key?(:send_user_id) ? options[:send_user_id] : (options.has_key?(:user) || options.has_key?(:password))
+
+      @qmf_explicit_auth = options[:mechanism] && options[:mechanism].upcase
+      raise "Invalid authentication mechanism #{@qmf_explicit_auth}" unless (!@qmf_explicit_auth || VALID_MECHANISMS.include?(@qmf_explicit_auth))
+
       @qmf_user = options[:user]
       @qmf_password = options[:password]
     end
@@ -195,6 +196,9 @@ module SPQR
       
       settings.username = @qmf_user if @qmf_sendUserId
       settings.password = @qmf_password if @qmf_sendUserId
+
+      implicit_mechanism = @qmf_sendUserId ? "PLAIN" : "ANONYMOUS"
+      settings.mechanism = @explicit_mechanism || implicit_mechanism
       
       @connection = Qmf::Connection.new(settings)
       @log.debug(" +-- @connection created:  #{@connection}")

data/ruby-spqr.spec.in

@@ -70,6 +70,12 @@ rm -rf %{buildroot}
 
 %changelog
 
+* Fri Feb 4 2011  <willb@redhat> - 0.3.3-1
+- support for alternate authentication mechanisms (BZ 675323)
+
+* Fri Dec 17 2010  <willb@redhat> - 0.3.2-2
+- packaging fixes (BZ 638569)
+
 * Wed Sep 15 2010  <willb@redhat> - 0.3.2-1
 - updated to version 0.3.2-1
 - removed spurious debugging output

data/test/helper.rb

@@ -35,7 +35,7 @@ module QmfTestHelpers
     end
     
     def event_received(event)
-      puts "GOT AN EVENT:  #{event} at #{Time.now.utc}"
+      puts "GOT AN EVENT:  #{event} at #{Time.now.utc}" if DEBUG
       @eq << event
     end
   end

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: spqr
 version: !ruby/object:Gem::Version 
-  version: 0.3.2
+  hash: 21
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 3
+  version: 0.3.3
 platform: ruby
 authors: 
 - William Benton
@@ -9,19 +15,25 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-15 00:00:00 -05:00
+date: 2011-02-04 00:00:00 -06: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 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 13
+        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: 
@@ -80,21 +92,27 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: "SPQR:  {Schema Processor|Straightforward Publishing} for QMF agents in Ruby"
@@ -109,7 +127,6 @@ 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

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