genprovider 0.2.0

data/lib/genprovider/rdoc.rb

@@ -0,0 +1,149 @@
+#
+# Genprovider::Class
+#
+
+#
+# make element description
+#
+
+module Genprovider
+  class RDoc
+    def description element
+      p = element.qualifiers["description", :string]
+      return unless p
+      p.value.split("\n").each do |l|
+	@out.puts l
+	@out.puts
+      end
+    end
+
+    #
+    # make feature doc
+    #
+
+    def doc_feature feature
+      k = feature.key? ? " [Key]" : nil
+      @out.puts "== #{feature.name} : #{feature.type.to_s}#{k}"
+      description feature
+      @out.puts
+      vm = feature.qualifiers["valuemap"]
+      vs = feature.qualifiers["values"]
+      if vm && vs
+	@out.puts "* Mapped values"
+	vm = vm.value
+	vs = vs.value
+	loop do
+	  m = vm.shift
+	  s = vs.shift
+	  @out.puts "  * #{m} -> #{s}"
+	  break if vm.empty? || vs.empty?
+	end
+      end
+      feature.qualifiers.each do |q|
+	n = q.name.downcase
+	next if n == "description"
+	next if n == "values" || n == "valuemap"
+	@out.puts "* #{q}"
+      end
+      @out.puts
+
+      return unless feature.method?
+      args = nil
+      feature.parameters.each do |p|
+	args ||= []
+	if p.qualifiers.include?(:out,:bool)
+	  args << "#{p.name.decamelize}_out"
+	else
+	  args << p.name.decamelize
+	end
+      end
+      n = feature.name.decamelize
+      @out.puts "* #{n}(#{args})"
+    end
+      
+    #
+    # generate code for property
+    #
+      
+    def doc_property property
+      doc_feature property
+    end
+
+    #
+    # generate code for reference
+    #
+      
+    def doc_reference reference
+      doc_feature reference
+    end
+    
+    #
+    # generate code for method
+    #
+    
+    def doc_method method
+      doc_feature method
+    end
+    
+    #
+    # generate provider code for features matching match
+    #
+    
+    def doc_features header, features, match
+      features.each do |f|
+	next unless f.instance_of? match
+	if header
+#	  @out.puts header
+	  header = nil
+	end
+	case f
+	when CIM::Property then doc_property f
+	when CIM::Reference then doc_reference f
+	when CIM::Method then doc_method f
+	else
+	  raise "Unknown feature class #{f.class}"
+	end
+      end
+    end
+    
+    def doc_class c = nil
+      c = @klass unless c
+      @out.puts "= #{c.name}"
+      description c
+      
+      if c.superclass
+	@out.puts
+	@out.puts "=== Superclass: #{c.superclass}"
+      end
+
+      doc_features "==Properties", c.features, CIM::Property
+      doc_features "==References", c.features, CIM::Reference
+      doc_features "==Methods", c.features, CIM::Method
+    end
+    
+    def each_parent
+      parent = @klass.parent
+      while parent
+	yield parent
+	parent = parent.parent
+      end
+    end
+
+    #
+    # generate provider code for class 'c'
+    #
+    
+    def initialize c, out
+      @klass = c
+      @out = out
+      @out.puts "= Documentation for #{c.name}"
+      each_parent do |k|
+	@out.puts "* #{k.name}"
+      end
+      doc_class
+      each_parent do |k|
+	doc_class k
+      end
+    end
+  end
+end

data/lib/genprovider/registration.rb

@@ -0,0 +1,22 @@
+#
+# registration.rb
+#
+
+module Genprovider
+  class Registration
+    def initialize c, namespace, providername, out
+      out.comment.comment "Registration for provider #{providername} of class #{c.class}"
+      out.comment.comment "Generated by 'genprovider' for use with cmpi-bindings-ruby"
+      out.comment.comment "Classname - Namespace - Providername - Libraryname - Capabilities ..."
+
+      mask = Genprovider.classmask c
+      capabilities = ""
+      capabilities << " instance" if (mask & INSTANCE_MASK) != 0
+      capabilities << " method" if (mask & METHOD_MASK) != 0
+      capabilities << " association" if (mask & ASSOCIATION_MASK) != 0
+      capabilities << " indication" if (mask & INDICATION_MASK) != 0
+
+      out.puts "#{c.name} #{namespace} #{providername} rbCmpiProvider#{capabilities}"
+    end
+  end
+end

data/lib/genprovider/testcase.rb

@@ -0,0 +1,139 @@
+#
+# testcase.rb
+#
+
+module Genprovider
+  class Testcase
+    # return Ruby type equivalent
+    def rubytype type
+      case type.to_sym
+      when :boolean then return ""
+      when :string then return "String"
+      when :char16 then return "Integer"
+      when :uint8 then return "Integer"
+      when :uint16 then return "Integer"
+      when :uint32 then return "Integer"
+      when :uint64 then return "Integer"
+      when :sint8 then return "Integer"
+      when :sint16 then return "Integer"
+      when :sint32 then return "Integer"
+      when :sint64 then return "Integer"
+      when :real32 then return "Float"
+      when :real64 then return "Float"
+      when :dateTime then return "Time"
+      when :reference then return "Sfcc::Cim::ObjectPath"
+      when :class then return "Sfcc::Cim::Class"
+      else
+        STDERR.puts "Unhandled type #{type}"
+      end
+    end
+    
+    def initialize c, namespace, out
+      out.comment.comment "Testcase for #{namespace}:#{c.name}"
+      out.comment.comment "Generated by 'genprovider' for use with cmpi-bindings-ruby"
+      out.puts "require 'rubygems'"
+      out.puts "require 'sfcc'"
+      out.puts "require 'test/unit'"
+      out.puts
+      out.puts "class Test_#{c.name} < Test::Unit::TestCase"
+      out.inc
+      out.def "setup"
+      out.puts "@client = Sfcc::Cim::Client.connect(:uri => 'https://wsman:secret@localhost:5989', :verify => false)"
+      out.puts "@op = Sfcc::Cim::ObjectPath.new('#{namespace}', '#{c.name}')"
+      out.end
+      out.puts
+      out.def "test_registered"
+      out.puts "cimclass = @client.get_class(@op)"
+      out.puts "assert cimclass"
+      out.end # test_registered
+      out.puts
+      out.def "test_instance_names"
+      out.puts "names = @client.instance_names(@op)"
+      out.puts "assert names.size > 0"
+      out.puts "names.each do |ref|"
+      out.inc
+      out.puts "ref.namespace = @op.namespace"
+      out.puts "instance = @client.get_instance ref"
+      out.puts "assert instance"
+      out.puts
+      #
+      # Properties
+      #
+      c.features.each do |p|
+        next unless p.property?
+        element = "instance.#{p.name}"
+        out.puts "assert #{element}"
+        if p.type.array?
+          out.puts "assert_kind_of Array, #{element} # #{p.type}"
+          out.puts "tmp = #{element}[0]"
+          element = "tmp"
+        end
+        rtype = rubytype p.type
+        raise "Unsupported type #{p.type} [#{rtype.class}]" if rtype.nil?
+        out.puts "if #{element}"
+        out.inc
+        if rtype.empty?
+          out.puts "assert #{element}.is_a?(TrueClass) || #{element}.is_a?(FalseClass)"
+        else
+          out.puts "assert_kind_of #{rubytype p.type}, #{element} # #{p.type}"
+        end
+        out.end
+      end
+      out.end #     names.each
+      out.end #   test_instance_names
+      #
+      # References
+      #
+      out.puts
+      c.features.each do |r|
+        next unless r.reference?
+      end
+      #
+      # Methods
+      #
+      out.puts
+      c.features.each do |m|
+        next unless m.method?
+        out.puts
+        out.def "test_method_#{m.name}"
+        if m.static?
+          # class-level method
+        else
+          # instance level method
+          out.puts "@client.instances(@op).each do |inst|"
+          out.inc
+          m.parameters.each do |p|
+            desc = p.description
+            out.comment desc if desc
+            if p.out?
+              out.puts "p_out_#{p.name} = {} # #{p.type}"
+            else
+              out.puts "p_in_#{p.name} = nil # #{p.type}"
+            end
+          end
+          s = "res = inst.#{m.name}("
+          first = true
+          m.parameters.each do |p|
+            if first
+              first = false
+            else
+              s << ", "
+            end
+            if p.includes? :out
+              s << "p_out_#{p.name}"
+            else
+              s << "p_in_#{p.name}"
+            end
+          end
+          s << ")"
+          out.puts s
+          out.puts "assert_kind_of #{rubytype m.type}, res"
+          out.end
+        end
+        out.end # test_method_<name>
+      end
+      out.puts
+      out.end # class
+    end
+  end
+end

data/lib/genprovider/version.rb

@@ -0,0 +1,3 @@
+module Genprovider
+  VERSION = '0.2.0'
+end

data/lib/genprovider.rb

@@ -0,0 +1,35 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module Genprovider
+  INSTANCE_MASK = 1
+  METHOD_MASK = 2
+  ASSOCIATION_MASK = 4
+  INDICATION_MASK = 8
+  
+  def self.classmask klass
+    c = klass
+    mask = 0
+    while c
+      mask |= INSTANCE_MASK if c.instance?
+      mask |= METHOD_MASK if c.method?
+      mask |= ASSOCIATION_MASK if c.association?
+      mask |= INDICATION_MASK if c.indication?
+      c = c.parent
+    end
+    if mask == 0
+      STDERR.puts "Assuming that #{klass.name} defines an Instance"
+      mask |= INSTANCE_MASK
+    end
+    mask
+  end
+
+  require 'genprovider/version'
+  require 'genprovider/output'
+  require 'genprovider/class'
+  require 'genprovider/provider'
+  require 'genprovider/registration'
+  require 'genprovider/testcase'
+  require 'genprovider/classinfo'
+  require 'genprovider/rdoc'
+end

data/samples/mof/LMI_Embedded.mof

@@ -0,0 +1,6 @@
+class LMI_Embedded
+{
+    [Key] string InstanceID;
+    [EmbeddedObject("CIM_ManagedElement")] string Embedded;
+    string Str;
+};

data/samples/mof/RCP_ArrayDataTypes.mof

@@ -0,0 +1,27 @@
+[ Description ("A dummy class to represent array data types" ) 
+]
+class RCP_ArrayDataTypes
+{
+  [Key]
+  string Name;
+  
+  boolean bool[];
+  
+  string text[];
+  char16 char_16[];
+  
+  uint8  unsigned_int_8[];
+  uint16 unsigned_int_16[];
+  uint32 unsigned_int_32[];
+  uint64 unsigned_int_64[];
+  
+  sint8  byte[];
+  sint16 short[];
+  sint32 int[];
+  sint64 long[];
+  
+  real32 float[];
+  real64 double[];
+
+  datetime date_time[];
+};

data/samples/mof/RCP_ClassMethod.mof

@@ -0,0 +1,7 @@
+[ Description ("A class method" ) 
+]
+class RCP_ClassMethod
+{
+  [Static, Description("A class method")]
+  string Classname();
+};

data/samples/mof/RCP_ComplexMethod.mof

@@ -0,0 +1,14 @@
+[ Description ("A class to implement complex methods" ) 
+]
+class RCP_ComplexMethod
+{
+  [Key]
+  string Name;
+  
+  [Description("A method to concatenate count * str, passing the"
+   "result via an out parameter. Returning the result length")]
+  uint32 InOut(uint32 count, [in] string str, [out] string result);
+  
+  [Description("A method to count array elements")]
+  uint32 Size([in] string strA[]);
+};

data/samples/mof/RCP_IndicationGenerator.mof

@@ -0,0 +1,13 @@
+/*
+ * sample indication generator
+ * modeled after
+ *   http://sourceforge.net/apps/mediawiki/pywbem/index.php?title=Indications_Tutorial
+ */
+
+class RCP_IndicationGenerator
+{
+  [Static, Description("Generate one or more indications")]
+  uint16 generate_indications(
+           string ind_text,
+           uint16 num_to_send );                                        
+};

data/samples/mof/RCP_PassCData.mof

@@ -0,0 +1,10 @@
+[ Description ("Passing CDATA string property values" ) 
+]
+class RCP_PassCData
+{
+  [Key]
+  string Name;
+  string Strange;
+  string CData;
+  string XmlData;
+};

data/samples/mof/RCP_ShowContext.mof

@@ -0,0 +1,11 @@
+[ Description ("A class to return the CMPIContext passed by the CIMOM" ) 
+]
+class RCP_ShowContext
+{
+  [Key]
+  string name;
+  [ Description ("Array of alternating key, value strings from"
+                 "CMPIContext." )
+  ]
+  string context[];
+};

data/samples/mof/RCP_SimpleClass.mof

@@ -0,0 +1,7 @@
+[ Description ("A simple class to detect memory leaks in cmpi-bindings" ) 
+]
+class RCP_SimpleClass
+{
+  [Key]
+  string Name;
+};

data/samples/mof/RCP_SimpleDataTypes.mof

@@ -0,0 +1,27 @@
+[ Description ("A dummy class to represent various data types" ) 
+]
+class RCP_SimpleDataTypes
+{
+  [Key]
+  string Name;
+  
+  boolean bool;
+  
+  string text;
+  char16 char_16;
+  
+  uint8  unsigned_int_8;
+  uint16 unsigned_int_16;
+  uint32 unsigned_int_32;
+  uint64 unsigned_int_64;
+  
+  sint8  byte;
+  sint16 short;
+  sint32 int;
+  sint64 long;
+  
+  real32 float;
+  real64 double;
+
+  datetime date_time;
+};

data/samples/mof/RCP_SimpleMethod.mof

@@ -0,0 +1,9 @@
+[ Description ("A simple class to implement methods" ) 
+]
+class RCP_SimpleMethod
+{
+  [Key]
+  string Name;
+
+  boolean ReturnTrue();
+};

data/samples/mof/qualifiers.mof

@@ -0,0 +1,20 @@
+//
+// qualifiers.mof - Qualifier definitions for stand-alone mof compilation
+//
+//
+
+#pragma locale ("en_US")
+//#pragma namespace ("root/cimv2")
+
+Qualifier Provider : string = null, 
+    Scope(any);
+Qualifier Description : string = null, 
+    Scope(any), 
+    Flavor(EnableOverride, ToSubclass, Translatable);
+Qualifier Key : boolean = false, 
+    Scope(property, reference), 
+    Flavor(DisableOverride, ToSubclass);
+Qualifier Association : boolean = false,
+    Scope(class);
+Qualifier Indication : boolean = false,
+    Scope(class);

data/samples/provider/lmi_embedded.rb

@@ -0,0 +1,148 @@
+#
+# Provider LMI_Embedded for class LMI_Embedded:CIM::Class
+#
+require 'syslog'
+
+require 'cmpi/provider'
+
+module Cmpi
+
+  class CIM_ManagedElement < InstanceProvider
+    # typemap for embedded instance
+    def self.typemap
+      {
+        "InstanceID" => Cmpi::string,
+        "Caption" => Cmpi::string,
+        "Description" => Cmpi::string,
+        "ElementName" => Cmpi::string,
+        "Generation" => Cmpi::uint64,
+      }
+    end
+  end
+  #
+  class LMI_Embedded < InstanceProvider
+    
+    #
+    # Provider initialization
+    #
+    def initialize( name, broker, context )
+      @trace_file = STDERR
+      super broker
+    end
+    
+    def cleanup( context, terminating )
+      @trace_file.puts "cleanup terminating? #{terminating}"
+      true
+    end
+    
+    def self.typemap
+      {
+        "InstanceID" => Cmpi::string,
+        "Embedded" => Cmpi::embedded_instance,
+        "Str" => Cmpi::string,
+      }
+    end
+
+    private
+    #
+    # Iterator for names and instances
+    #  yields references matching reference and properties
+    #
+    def each( context, reference, properties = nil, want_instance = false )
+      value = "Hello world"
+      
+      # create embedded instance
+      ns = reference.namespace
+      pembedded = Cmpi::CMPIObjectPath.new ns, "CIM_ManagedElement"
+      pembedded.InstanceID = "id"
+      @trace_file.puts "pembedded #{pembedded}"
+      
+      embedded = Cmpi::CMPIInstance.new pembedded
+      embedded.Description = "descr"
+
+      result = Cmpi::CMPIObjectPath.new reference.namespace, "LMI_Embedded"
+      if want_instance
+        result = Cmpi::CMPIInstance.new result
+      end
+    
+      # Set key properties
+      
+      result.InstanceID = "Hello world" # string  (-> LMI_Embedded)
+      unless want_instance
+        yield result
+        return
+      end
+      
+      # Instance: Set non-key properties
+      
+      result.Embedded = embedded
+      result.Str = "sample string"
+      yield result
+    end
+    public
+    
+    def enum_instance_names( context, result, reference )
+      @trace_file.puts "enum_instance_names ref #{reference}"
+      each(context, reference) do |ref|
+        @trace_file.puts "ref #{ref}"
+        result.return_objectpath ref
+      end
+      result.done
+      true
+    end
+    
+    def enum_instances( context, result, reference, properties )
+      @trace_file.puts "enum_instances ref #{reference}, props #{properties.inspect}"
+      each(context, reference, properties, true) do |instance|
+        @trace_file.puts "instance #{instance}"
+        result.return_instance instance
+      end
+      result.done
+      true
+    end
+    
+    def get_instance( context, result, reference, properties )
+      @trace_file.puts "get_instance ref #{reference}, props #{properties.inspect}"
+      each(context, reference, properties, true) do |instance|
+        @trace_file.puts "instance #{instance}"
+        result.return_instance instance
+        break # only return first instance
+      end
+      result.done
+      true
+    end
+    
+    def create_instance( context, result, reference, newinst )
+      @trace_file.puts "create_instance ref #{reference}, newinst #{newinst.inspect}"
+      # Create instance according to reference and newinst
+      result.return_objectpath reference
+      result.done
+      true
+    end
+    
+    def set_instance( context, result, reference, newinst, properties )
+      @trace_file.puts "set_instance ref #{reference}, newinst #{newinst.inspect}, props #{properties.inspect}"
+      properties.each do |prop|
+        newinst.send "#{prop.name}=".to_sym, FIXME
+      end
+      result.return_instance newinst
+      result.done
+      true
+    end
+    
+    def delete_instance( context, result, reference )
+      @trace_file.puts "delete_instance ref #{reference}"
+      result.done
+      true
+    end
+    
+    # query : String
+    # lang : String
+    def exec_query( context, result, reference, query, lang )
+      @trace_file.puts "exec_query ref #{reference}, query #{query}, lang #{lang}"
+      result.done
+      true
+    end
+    
+  end
+end