wbem 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 87b68ff6a2d000a5a3d48ca45b80457b2e09510e
-  data.tar.gz: 485f24baa3f7b857f23a41c6d083ae335207f6ea
+  metadata.gz: a9c0a1ba0bac70d9aa7e910153bf46837a6dd305
+  data.tar.gz: 232a5e958d2e5456ba907379228e0304a32ae82c
 SHA512:
-  metadata.gz: c0d17fee71e8379c960add9b3d250afa20ff15b06588b701a6a386396d5fa6f263bacb233f531c70955b02e2ce3bdc57025bdbde36cac9db495e85b5bd5c18e6
-  data.tar.gz: 4d5d1ba803e1a93d2b3802dd1ae44e4fdf5c35788507e5e30d0f06b6042fb5d1569c63fab10784b0d589e86f091e75a40b5dcf90482d4a9ae61f88afa71ed9f1
+  metadata.gz: 364d2f6af56cfc32aecf396f546aaa85461d0dbb1f123a5db9d9e2f6c2dfc722da657df5db9378d3f52e8b7ef092b71a8ebbe7406d90113f3739bce5d63539ff
+  data.tar.gz: c4d5401ac945660197fa4cb0340da43086a638236d0828be2e3cb61010db996a793fc7d62604d59d678ab0f544437917d33e3d6a1bd7819768dbb0d17c55d332

data/CHANGELOG.rdoc

@@ -1,3 +1,23 @@
+== 0.5.0
+
+* Add client.get for fetching instances with keys in Cimxml
+
+== 0.4.0
+
+* Add bin/genclassinfo to generate Ruby classes from MOF
+* Add client.get for fetching instances with keys in Wsman
+* Properly handle EndpointReferences
+* Add Instance#invoke, based on type information from generated Ruby
+  class
+
+== 0.3.2
+
+* Add Client#get to get an instance by ObjectPath
+
+== 0.3.1
+
+* Add Client#get to get an instance by EndPointReference
+
 == 0.3.0
 
 * Add Client#profiles to enumerate CIM_RegisteredProfile

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+
+Copyright (c) 2009 Novell Inc.
+ 
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+ 
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+task :default => [:test]

data/bin/genclassinfo

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+#
+# genclassinfo
+#
+#  Generate Ruby class templates
+#
+# Copyright (c) 2015 Klaus Kämpf <kkaempf@suse.de>
+#
+# Licensed under the Ruby license
+#
+# == Usage
+#
+# genclassinfo [-d] [-h] [-q] [-I <includedir>] [-o <output>] <moffile> [<moffile> ...]
+#
+# -d:
+#   turn on debugging
+# -h:
+#   show (this) help
+# -q:
+#   be quiet
+# -I <includedir>
+#   additional include directories to search
+# -o <outputdir>
+#   directory to write generated files, defaults to 'generated'
+# <moffile>
+#   .mof files to read
+#
+
+require 'rubygems'
+
+require 'mof'
+require 'pathname'
+require 'fileutils'
+
+$:.push(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'wbem'
+
+def usage msg=nil
+  STDERR.puts "Err: #{msg}" if msg
+  STDERR.puts "Usage: genclassinfo [-d] <class> [ <class> ...]"
+  exit (msg)?1:0
+end
+
+#--------------------------------------------------------------------
+
+@factory = Wbem::ClassFactory.new
+
+if ARGV.empty?
+  usage
+end
+
+ARGV.each do |c|
+  if c == "-d"
+    Wbem::debug = 1
+    next
+  end
+  @factory.gen_class c
+end

data/lib/wbem.rb

@@ -9,6 +9,10 @@
 # Licensed under the MIT license
 #
 module Wbem
+  require 'wbem/class_factory'
+  require 'wbem/conversion'
+  require 'wbem/wbem'
+
   @@debug = nil
   def Wbem.debug
     @@debug
@@ -19,8 +23,6 @@ module Wbem
 
   class Client
     require 'uri'
-    require 'wbem/wsman'
-    require 'wbem/cimxml'
 
     #
     # Wbem::Client.connect uri, protocol = nil
@@ -32,7 +34,7 @@ module Wbem
     # else    - probe connection (cim/xml first)
     #
     def self.connect uri, protocol = nil, auth_scheme = nil
-      STDERR.puts "Wbem::Client.connect(#{uri},#{protocol},#{auth_scheme})"
+      STDERR.puts "Wbem::Client.connect(#{uri},#{protocol},#{auth_scheme})" if Wbem.debug
       unless uri.is_a?(URI)
         u = URI.parse(uri)
         # u.port will be set in any case, so check the uri for port specification
@@ -46,16 +48,18 @@ module Wbem
         unless protocol_given
           u.port = (u.scheme == "http") ? 5985 : 5986
         end
+        require 'wbem/wsman'
         return WsmanClient.new u, auth_scheme
       when "cimxml"
         unless protocol_given
           u.port = (u.scheme == "http") ? 5988 : 5989
         end
+        require 'wbem/cimxml'
         return CimxmlClient.new u
       end
       # no connect, check known ports
       case u.port
-      when 8888, 8889, 5985, 5986
+      when 8888, 8889, 5985, 5986, 16992
         return Wbem::Client.connect u, :wsman, auth_scheme
       when 5988, 5989
         return Wbem::Client.connect u, :cimxml, auth_scheme

data/lib/wbem/cimxml.rb

@@ -51,6 +51,43 @@ private
 
 public
 
+  #
+  # parse ObjectPath to Sfcc::Cim::ObjectPath
+  # 1. root/cimv2:Linux_ComputerSystem.CreationClassName="Linux_ComputerSystem",Name="foo.bar"
+  # 2. localhost:5989/root/cimv2:Linux_ComputerSystem.CreationClassName="Linux_ComputerSystem",Name="heron.suse.de"
+  #
+  #
+  def self.parse_object_path s
+    op = nil
+    front, values = s.split(".",2)
+    STDERR.puts "self.parse_object_path >#{front}<(#{values})"
+    frontargs = front.split(":")
+    if frontargs.size == 2
+      # case 1 above
+      namespace, classname = frontargs
+      op = Sfcc::Cim::ObjectPath.new(namespace, classname)
+    elsif frontargs.size == 3
+      host, port_and_namespace, classname = frontargs
+      port, namespace = port_and_namespace.split("/", 2)
+      op = Sfcc::Cim::ObjectPath.new(namespace, classname)      
+    else
+      raise "CimxmlClient.parse_object_path: Can't parse >#{frontargs.inspect}<"
+    end
+    # add values
+    while values && !values.empty?
+      puts "Values >#{values.inspect}<"
+      name, rest = values.split("=", 2)
+      arg, values = if rest[0,1] == '"' # quoted arg
+                      rest[1..-1].split(/\",?/, 2)
+                    else # non-quoted arg
+                      rest.split(",", 2)
+                    end
+      puts "name(#{name}), arg(#{arg})"
+      op.add_key(name, arg)
+    end
+    puts "Op #{op}"
+    op
+  end
   #
   # Initialize a CIMXML client connection
   #
@@ -125,10 +162,12 @@ public
   # @param properties : Hash (optional)
   #
   def instance_names namespace, classname=nil, properties={}
+    # if namespace is unset, sfcc will generate invalid XML
+    namespace ||= "root/cimv2"
     case namespace
     when Sfcc::Cim::ObjectPath
       objectpath = namespace
-      namespace = objectpath.namespace
+      namespace = objectpath.namespace      
     else
       objectpath = objectpath namespace.to_s, classname, properties
     end
@@ -143,6 +182,32 @@ public
     ret
   end
 
+  #
+  # get instance by reference
+  #
+  # call-seq
+  #   get Sfcc::Cim::ObjectPath -> Wbem::Instance
+  #   get ObjectPath-as-String -> Wbem::Instance
+  #   get "ClassName", "key" => "value", :namespace => "root/interop"
+  #
+  def get instance_reference, keys = nil
+    if keys
+      namespace = keys.delete(:namespace) || "root/cimv2"
+      instance_reference = Sfcc::Cim::ObjectPath.new(namespace, instance_reference)
+      keys.each do |k,v|
+        instance_reference.add_key k, v
+      end
+    end
+    puts "@client.get #{instance_reference.class}..." if Wbem.debug
+    case instance_reference
+    when Sfcc::Cim::ObjectPath
+      get_by_objectpath instance_reference
+    when String
+      get_by_objectpath CimxmlClient.parse_object_path(instance_reference)
+    else
+      raise "Unsupported Wbem::get #{instance_reference.class}"
+    end
+  end
   #
   # Return matching Wbem::Instance for first instance
   #  matching namespace, classname, properties
@@ -190,5 +255,12 @@ public
     end
   end
   
+  #
+  # get instance by objectpath
+  #
+  def get_by_objectpath objpath
+    STDERR.puts "#{self.class}.get_by_objectpath #{objpath}" if Wbem.debug
+    @client.get_instance(objpath)
+  end
 end # class
 end # module

data/lib/wbem/class_factory.rb

@@ -0,0 +1,163 @@
+#
+# Class Factory
+#
+#
+# Creates CIM class with ancestry chain
+#
+#  Base class: Wbem::Instance
+#
+module Wbem
+  class ClassFactory
+    MOFBASE = "/usr/share/mof/cim-current"
+    AMTBASE = "/usr/share/mof/iAMT/MOF"
+    QUALIFIERS = "qualifiers.mof"
+    SCHEMATA = { MOFBASE => "CIM_Schema.mof", AMTBASE => "amt.mof" }
+    CLASSDIR = "wbem"
+    require 'cim'
+    require 'mof'
+    require 'pathname'
+    
+    #
+    # Constructor
+    #
+    def initialize basepath = nil
+      @basedir = File.expand_path(File.join(basepath || Dir.getwd, CLASSDIR))
+    end
+  private
+
+    #
+    # parse_with_ancestors
+    #
+    # Find the superclass name of a class, parse its mof file
+    # returns Hash of { classname -> CIM::Class }
+    #
+
+    def parse_with_ancestors name
+      # find .mof file
+      mofdata = classmap()[name]
+      unless mofdata
+        raise "Can't find MOF for #{name}"
+      end
+      mofpath = mofdata[:path]
+      # parsed before ?
+      mof = mofdata[:mof] rescue nil
+      unless mof
+        # not parsed, parse now
+        puts "Reading mof from #{mofpath}" if Wbem.debug
+        begin
+          mofs = parser().parse [ QUALIFIERS, "qualifiers_intel.mof", mofpath ]
+        rescue Exception => e
+          parser.error_handler e
+        end
+#        puts "==> #{mofs.inspect}"
+        # Iterate over all parsed classes
+        mofs[mofpath].classes.each do |mofclass|
+          next unless mofclass.name == name
+          classmap()[name] = { :path => mofpath, :mof => mofclass }
+          if mofclass.superclass
+            parse_with_ancestors mofclass.superclass
+          end
+        end
+      end
+    end
+
+    #
+    # generate method parameter information
+    # return nil if no parameters
+    #
+    def gen_method_parameters direction, parameters, file
+      return if parameters.empty?
+      file.print "#{direction.inspect} => ["
+      first = true
+      parameters.each do |p|
+        if first
+          first = false
+        else
+          file.print ", "
+        end
+        # [ <name>, <type>, <out>? ]
+        file.print "#{p.name.inspect}, #{p.type.to_sym.inspect}"
+      end
+      file.print "]"
+      return true
+    end
+    #
+    # generate .rb class declaration
+    #
+    def generate name, file
+      require 'erb'
+      template = File.read(File.join(File.dirname(__FILE__), "class_template.erb"))
+      erb = ERB.new(template)
+      code = erb.result(binding)
+      Dir.mkdir(@basedir) unless File.directory?(@basedir)
+      File.open(file, "w+") do |f|
+        f.puts code
+      end
+    end
+    
+    #
+    # classmap - generate map of classes and their .mof files
+    #
+    def classmap
+      return @classmap if @classmap
+      # read SCHEMA and build class index to find .mof files quickly
+      @classmap = Hash.new
+      @includes = [ Pathname.new(".") ]
+      SCHEMATA.each do |base, file|
+        @includes << base
+        allow_cim = (file =~ /^CIM_/) # allow CIM_ only for CIM_Schema.mof
+        File.open(File.join(base, file)) do |f|
+          f.each do |l|
+            if l =~ /^\#pragma\sinclude\s?\(\"(([\w\/_]+)\.mof)\"\).*/
+              # $1 Foo/Bar.mof
+              # $2 Foo/Bar
+              path = $1
+              names = $2.split("/")
+              name = names[1] || names[0]
+              next unless name =~ /_/ # class name must have underscore (rules out 'qualifiers.mof')
+#              puts "#{path}:#{name}"
+              next if !allow_cim && name =~ /^CIM_/ # skip CIM_ mofs unless allowed
+              if @classmap[name]
+                raise "Dup #{name} : #{@classmap[name]}"
+              else
+                @classmap[name] = { :path => path }
+              end
+            end
+          end
+        end
+      end
+      STDERR.puts "Found MOFs for #{@classmap.size} classes" if Wbem.debug
+      @classmap
+    end
+
+    #
+    # MOF parser access
+    #
+    def parser
+      @parser ||= MOF::Parser.new :style => :cim, :includes => @includes, :quiet => true
+    end
+  public
+    #
+    # Class Factory
+    #
+    def class_for name
+      begin
+        path = "#{@basedir}/#{name}"
+        require path
+        return Object.const_get("Wbem").const_get(name)
+      rescue LoadError
+        raise "'#{path}.rb' not found, use 'genclass' of ruby-wbem to generate class '#{name}'"
+      end
+    end
+    #
+    # gen_class
+    #
+    def gen_class name
+      mofname = name + ".mof"
+      classpath = File.join(@basedir, "#{name}.rb")
+      parse_with_ancestors name
+      generate name, classpath
+      class_for name
+    end # def create
+  end # class ClassFactory
+end # module Wbem

data/lib/wbem/class_template.erb

@@ -0,0 +1,48 @@
+<%
+  # @classes[name] = { :path => mofpath, :mof => mofclass }
+
+  def collect_superclasses name
+    classdata = @classmap[name]
+    raise "No such class: #{name}" unless classdata
+    mofclass = classdata[:mof]
+    superclass = mofclass.superclass
+    [mofclass] + ((superclass)?collect_superclasses(superclass):[])
+  end
+%>
+
+# Class information for <%= name %>
+# Generated by 'wbem' for use with ruby-wbem
+
+require 'rubygems'
+require 'cim'
+require 'wbem'
+
+module Wbem
+
+  class <%= name %> < Wbem::Instance
+<% classes = collect_superclasses name %>
+<% known_features = Hash.new %>
+    TYPEMAP = {
+<%    classes.each do |mofclass|
+        mofclass.features.each do |f|
+          next if known_features[f.name]
+          known_features[f.name] = f
+          if f.method? %>
+        # <%= mofclass.name %>.<%= f.name %>()
+        <%= f.name.inspect %> => [ <%= f.type.to_sym.inspect %>, <% f.parameters.each do |p| %>
+            [ <%= p.name.inspect %>, <%= p.type.to_sym.inspect %>, <%= (p.includes?(:out))?":out":":in" %> ], <% end %>
+          ],
+        <% else %>
+        # <%= mofclass.name %>.<%= f.name %>
+        <%= f.name.inspect %> => <%= f.type.to_sym.inspect %>,
+<%        end
+        end
+      end %>
+    }
+    
+    def _typemap
+      TYPEMAP
+    end
+
+  end # class
+end # module