wbem 0.3.0 → 0.5.0

data/lib/wbem/conversion.rb

@@ -0,0 +1,173 @@
+#
+# Type conversion
+#
+
+require 'openwsman'
+
+module Wbem
+  class Conversion
+  #
+  # Convert CIM DateTime string representation (see DSP0004, 2.2.1)
+  # to Ruby Time (timestamp) or Float (interval, as seconds with fraction)
+  #           00000000001111111111222222
+  #           01234567890123456789012345
+  # East:     yyyymmddhhmmss.mmmmmm+utc -> Time (utc = offset in minutes)
+  # West:     yyyymmddhhmmss.mmmmmm-utc -> Time
+  #           2011-11-01T00:00:00Z
+  # Interval: ddddddddhhmmss.mmmmmm:000 -> Float (interval in seconds, with fraction)
+  #
+  def self.cimdatetime_to_ruby str
+#    puts "Cmpi.cimdatetime_to_ruby(#{str})"
+    case str[21,1]
+    when '+', '-'
+      # create Time from yyyymmddhhmmss and utc
+      t = Time.new(str[0,4].to_i, str[4,2].to_i, str[6,2].to_i, str[8,2].to_i, str[10,2].to_i, str[12,2].to_i, str[22,3].to_i * ((str[21,1]=='+')?60:-60))
+      off = str[15,6].to_i / 1000
+      # Add fractional part
+      return t + off
+    when ':'
+      # time offset
+      off = str[0,8].to_i * 24 * 60 * 60
+      off += str[8,2].to_i * 60 * 60 + str[10,2].to_i * 60 + str[12,2].to_i
+      off += str[15,6].to_i / 1000
+      return off
+    when nil
+      # 2011-11-01T00:00:00Z
+      t = Time.new(str[0,4].to_i, str[5,2].to_i, str[8,2].to_i, str[11,2].to_i, str[14,2].to_i, str[17,2].to_i, (str[19,1] == 'Z')?0:0)
+    else
+      begin
+        require 'date'
+        DateTime.parse str
+      rescue
+        raise ::TypeError.new("Invalid CIM DateTime '#{str}'")
+      end
+    end
+  end
+
+  #
+  # Convert Ruby value to CIM DateTime string representation (see DSP0004, 2.2.1)
+  #           00000000001111111111222222
+  #           01234567890123456789012345
+  # East:     yyyymmddhhmmss.mmmmmm+utc -> Time (utc = offset in minutes, mmmmmm is the microsecond within the second
+  # West:     yyyymmddhhmmss.mmmmmm-utc -> Time
+  # Interval: ddddddddhhmmss.mmmmmm:000 -> Float (interval in seconds, with fraction)
+  #
+  def self.ruby_to_cimdatetime val
+    require 'date'
+#    puts "Cmpi.ruby_to_cimdatetime(#{val}[#{val.class}])"
+    t = nil
+    case val
+    when Time
+      s = val.strftime "%Y%m%d%H%M%S.%6N"
+      utc = val.utc_offset # offset in seconds
+      if utc < 0
+        s << "-"
+        utc = -utc
+      else
+        s << "+"
+      end
+      val = s + ("%03d" % (utc/60))
+    when Numeric
+      if val < 0
+        # treat it as seconds before epoch
+        val = self.ruby_to_cimdatetime( Time.at(val) )
+      else
+        # treat as interval in microseconds
+        secs = (val / 1000000).to_i
+        usecs = (val % 1000000).to_i
+        days = secs / (24 * 60 * 60)
+        secs = secs % (24 * 60 * 60) # seconds within the day
+        hours = (secs / (60 * 60)).to_i
+        secs = secs % (60 * 60)
+        mins = (secs / 60).to_i
+        secs = secs % 60
+        val = "%08d%02d%02d%02d.%06d:000" % [ days, hours, mins, secs, usecs ]
+      end
+    when /^\d{14}\.\d{6}[-+:]\d{3}$/
+      # fallthru
+    when String
+      val = self.ruby_to_cimdatetime val.to_f # retry as Numeric
+    else
+      val = self.ruby_to_cimdatetime val.to_s # retry as string
+    end
+    val
+  end
+  
+    # generic type conversion
+    # CIM -> Ruby
+    #
+    def self.to_ruby type, value
+      text = case value
+             when Openwsman::XmlNode
+               value.text
+             when String
+               value
+             else
+               value.to_s
+             end
+      case type
+      when :null,:void
+        nil
+      when :boolean
+        text == 'true'
+      when :char16
+        text.to_i
+      when :string
+        text
+      when :uint8,:sint8,:uint16,:sint16,:uint32,:sint32,:uint64,:sint64
+        text.to_i
+      when :real32,:real64
+        text.to_f
+      when :dateTime
+        Wbem::Conversion.cimdatetime_to_ruby text
+      when :class
+#        puts "to_ruby :class, #{value.to_xml}"
+        uri = value.ResourceURI
+        if uri # assume ResourceURI and SelectorSet
+#          puts "to_ruby :class uri #{uri.text}"
+          epr = Openwsman::EndPointReference.new(uri.text)
+          value.SelectorSet.each do |s|
+            k = s.attr("Name").value
+            v = s.text
+            epr.add_selector(k, v)
+          end
+          epr
+        else
+        # try EndpointReference
+          Openwsman::EndPointReference.new(value.to_xml)
+        end
+      #      when :class
+      #      when :reference
+      #      when :array
+      else
+        raise "Unhandled type in to_ruby #{type.inspect}"
+      end
+    end
+    # generic type conversion
+    # Ruby -> CIM
+    #
+    def self.from_ruby type, value
+      case type
+      when :null,:void
+        ""
+      when :boolean
+        (value)?'true':'false'
+      when :char16
+        value.to_s
+      when :string
+        value.to_s
+      when :uint8,:sint8,:uint16,:sint16,:uint32,:sint32,:uint64,:sint64
+        value.to_i.to_s
+      when :real32,:real64
+        value.to_f.to_s
+      when :dateTime
+        Wbem::Conversion.ruby_to_cimdatetime value
+      #      when :class
+      #      when :reference
+      #      when :array
+      else
+        raise "Unhandled type in from_ruby #{type.inspect}"
+      end
+    end
+  end # class Conversion
+end # module Wbem

data/lib/wbem/openwsman.rb

@@ -0,0 +1,51 @@
+#
+# Openwsman helper methods for wbem/wsman-instance
+#
+
+module Openwsman
+  class Transport
+    def Transport.auth_request_callback( client, auth_type )
+      STDERR.puts "\t *** Transport.auth_request_callback"
+      return nil
+    end
+  end
+  #
+  # Capture Fault as Exception
+  #
+  class Exception < ::RuntimeError
+    def initialize fault
+      unless fault.is_a? Openwsman::Fault
+        raise "#{fault} is not a fault" unless fault.fault?
+        fault = Openwsman::Fault.new fault
+      end
+      @fault = fault
+    end
+    def to_s
+      "Fault code #{@fault.code}, subcode #{@fault.subcode}" +
+      "\n\treason \"#{@fault.reason}\"" +
+      "\n\tdetail \"#{@fault.detail}\""
+    end
+  end
+  #
+  # Capture namespace, classname, and properties as ObjectPath
+  #
+  class ObjectPath
+    attr_reader :namespace, :classname, :properties
+    def initialize namespace, classname = nil, properties = {}
+      @namespace = namespace
+      @classname = classname
+      @properties = properties
+    end
+  end
+  #
+  # Provide Cim::ObjectPath like accessors for EndPointReference
+  #
+  class EndPointReference
+    alias :keys :selector_names
+    alias :key_count :selector_count
+    alias :add_key :add_selector
+    def each_key
+      keys.each { |key| yield key }
+    end
+  end
+end

data/lib/wbem/version.rb

@@ -1,3 +1,3 @@
 module Wbem
-  VERSION = "0.3.0"
+  VERSION = "0.5.0"
 end

data/lib/wbem/wbem.rb

@@ -8,6 +8,10 @@
 # Licensed under the MIT license
 #
 module Wbem
+  # class forward declaration
+  class WbemClient; end
+  class WsmanClient < WbemClient; end
+  class CimxmlClient < WbemClient; end
   #
   # WbemClient - base class for CimxmlClient and WsmanClient
   #
@@ -23,6 +27,10 @@ module Wbem
       @auth_scheme = auth_scheme.to_s.to_sym rescue nil
     end
 
+    def factory
+      @factory ||= Wbem::ClassFactory.new
+    end
+
     def response_code
       @client.response_code
     end
@@ -44,7 +52,59 @@ public
     def class_names op, deep_inheritance=false
       raise "#{self.class}.class_names not implemented"
     end
-  
+
+    #
+    # Enumerate class refs
+    # Returns Array of Instance References (Sfcc::Cim::ObjectPath or Openwsman::EndPointReference)
+    #
+    def enumerate classname
+      raise "#{self.class}.enumerate not implemented"
+    end
+
+    #
+    # get instance by reference
+    #
+    # call-seq
+    #   get Openwsman::EndPointReference -> Wbem::Instance
+    #   get Sfcc::Cim::ObjectPath -> Wbem::Instance
+    #   get EndPointReference-as-String -> Wbem::Instance
+    #   get ObjectPath-as-String -> Wbem::Instance
+    #   get "ClassName", "key" => "value", :namespace => "root/interop"
+    #
+    def get instance_reference, keys = nil
+      if keys
+        if self.class == Wbem::WsmanClient
+          uri = Openwsman.epr_uri_for "", instance_reference
+          instance_reference = Openwsman::EndPointReference.new(uri, nil, keys)
+        elsif self.class == Wbem::CimxmlClient
+          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
+      end
+      puts "@client.get #{instance_reference.class}..." if Wbem.debug
+      case instance_reference
+      when Openwsman::EndPointReference
+        get_by_epr instance_reference
+      when Sfcc::Cim::ObjectPath
+        get_by_objectpath instance_reference
+      when String
+        if self.class == WsmanClient
+          get_by_epr Openwsman::EndPointReference.new(instance_reference)
+        elsif self.class == CimxmlClient
+          get_by_objectpath CimxmlClient.parse_object_path(instance_reference)
+        else
+          raise "Unsupported Wbem::get #{instance_reference.class} for #{self.class}"
+        end
+      else
+        raise "Unsupported Wbem::get #{instance_reference.class}"
+      end
+    end
+    #
+    # ComputerSystem
+    #
     def system_class_name
       case @product
       when :winrm then "Win32_ComputerSystem"
@@ -56,7 +116,10 @@ public
       ns = "" if @product == :iamt
       instance_names ns, system_class_name
     end
-    
+
+    #
+    # RegisteredProfile
+    #
     def profile_class_name
       "CIM_RegisteredProfile"
     end
@@ -64,7 +127,10 @@ public
       ns = "" if @product == :iamt
       instance_names ns, profile_class_name
     end
-    
+
+    #
+    # Service
+    #
     def service_class_name
       case @product
       when :winrm then "Win32_Service"
@@ -80,6 +146,10 @@ public
       ns = "" if @product == :iamt
       instance_names ns, (@product == :winrm) ? "Win32_Process" : "CIM_Process"
     end
+
+    #
+    # NetworkAdapter, NetworkPort
+    #
     def network_class_name
       case @product
       when :winrm then "Win32_NetworkAdapter"
@@ -92,6 +162,10 @@ public
       ns = "" if @product == :iamt
       instance_names ns, network_class_name
     end
+
+    #
+    # DiskDrive, StorageExtent
+    #
     def storage_class_name
       case @product
       when :winrm then "Win32_DiskDrive"
@@ -105,5 +179,35 @@ public
       instance_names ns, storage_class_name
     end
 
-  end # Class
+  end # Class WbemClient
+  
+  #
+  # Instance class
+  #
+  # Represents instance of a CIM object on a client
+  #
+  # *ABSTRACT*
+  #
+  # Gets instantiated via a CIM class generated by 'genclassinfo'
+  #
+  #
+  class Instance
+    private
+    #
+    #
+    #
+    def initialize client, reference, data = nil
+      case client
+      when Wbem::WsmanClient
+        require "wbem/wsman_instance"
+        self.extend(WsmanInstance)
+        wsman_initialize client, reference, data
+      when Wbem::CimxmlClient
+        self.extend(CimxmlInstance)
+        cimxml_initialize client, reference, data
+      else
+        STDERR.puts "Unkwown client class #{client.class}"
+      end
+    end
+  end
 end # Module

data/lib/wbem/wsman.rb

@@ -8,164 +8,13 @@
 # Licensed under the MIT license
 #
 require "wbem/wbem"
+require "wbem/wsman_instance"
 require "openwsman"
-
-class AuthError < StandardError
-end
-
-module Openwsman
-  class Transport
-    def Transport.auth_request_callback( client, auth_type )
-      STDERR.puts "\t *** Transport.auth_request_callback"
-      return nil
-    end
-  end
-  #
-  # Capture Fault as Exception
-  #
-  class Exception < ::RuntimeError
-    def initialize fault
-      unless fault.is_a? Openwsman::Fault
-        raise "#{fault} is not a fault" unless fault.fault?
-        fault = Openwsman::Fault.new fault
-      end
-      @fault = fault
-    end
-    def to_s
-      "Fault code #{@fault.code}, subcode #{@fault.subcode}" +
-      "\n\treason #{@fault.reason}" +
-      "\n\tdetail #{@fault.detail}"
-    end
-  end
-  #
-  # Capture namespace, classname, and properties as ObjectPath
-  #
-  class ObjectPath
-    attr_reader :namespace, :classname, :properties
-    def initialize namespace, classname = nil, properties = {}
-      @namespace = namespace
-      @classname = classname
-      @properties = properties
-    end
-  end
-  #
-  # Provide Cim::ObjectPath like accessors for EndPointReference
-  #
-  class EndPointReference
-    alias :keys :selector_names
-    alias :key_count :selector_count
-    alias :add_key :add_selector
-    def each_key
-      keys.each { |key| yield key }
-    end
-  end
-  #
-  # Capture XmlDoc + WsmanClient as Instance
-  #
-  class Instance
-    def initialize node, client, epr_or_uri
-      @node = (node.is_a? Openwsman::XmlDoc) ? node.body : node
-      @epr = (epr_or_uri.is_a? Openwsman::EndPointReference) ? epr_or_uri : Openwsman::EndPointReference.new(epr_or_uri)
-      @client = client
-    end
-    #
-    #
-    #    
-    def to_s
-      "Instance #{@client}\n\t#{@epr}\n\t#{@node.to_xml}"
-    end
-    #
-    # Instance#<property>
-    # Instance#<method>(<args>)
-    #
-    def method_missing name, *args
-      if args.empty?
-        # try property first
-        res = @node.send name
-        return res.text if res
-      end
-      # try as method invocation
-      options = Openwsman::ClientOptions.new
-      options.set_dump_request
-      selectors = {}
-      @epr.each do |k,v|
-        selectors[k] = v
-      end
-      options.selectors = selectors # instance key properties
-      uri = @epr.resource_uri
-	
-      #
-      # get method input parameter information
-      #
-      classname = @epr.classname
-      s = "mof/#{classname}"
-      begin
-        require s
-      rescue LoadError
-        raise RuntimeError.new "Cannot load #{s} for type information"
-      end
-      methods = MOF.class_eval "#{classname}::METHODS"
-      method = methods[name.to_s]
-      raise RuntimeError.new("Unknown method #{name} for #{classname}") unless method
-      result_type = method[:type]
-      parameters = method[:parameters] || {}
-      input = parameters[:in]
-      output = parameters[:out]
-      argsin = {}
-      i = 0
-      if input
-        while i < input.size
-          value = args.shift
-          raise "Argument for #{input[i]} is nil, not allowed !" unless value
-          argsin[input[i]] = value
-          # FIXME more typecheck of args ?
-          i += 2
-        end
-      end
-      STDERR.puts "\n\tproperties #{argsin.inspect}\n"
-      options.properties = argsin
-      #
-      # output parameters ?
-      #
-      argsout = nil
-      if output
-        if args.empty?
-          raise "Function #{name} has output arguments, please add an empty hash to the call"
-        end
-        argsout = args.shift
-        unless argsout.kind_of? Hash
-          raise "Function #{name} has output arguments, last argument must be a Hash"
-        end
-        unless args.empty?
-          raise "Function call to #{name} has excess arguments"
-        end
-      end
-      STDERR.puts "\n\targsout #{argsout.inspect}\n"
-Openwsman.debug = -1
-      STDERR.puts "\n\tinvoke #{uri}.#{name}\n"
-      res = @client.client.invoke(options, uri, name.to_s)
-      raise Openwsman::Exception.new(res) if res.fault?
-      STDERR.puts "\n\tresult #{res.to_xml}\n"
-      result = res.find(uri, "#{name}_OUTPUT").find(uri, "ReturnValue").text
-      case result_type
-      when :boolean
-        result == "true" ? true : false
-      when :uint8, :uint16, :uint32, :uint64
-        result.to_i
-      when :string
-        result
-      when :float
-        result.to_f
-      when :datetime
-      else
-        raise "Unsupported result_type #{result_type.inspect}"
-      end
-    end
-  end
-end
-
+require "wbem/openwsman"
+require "cim"
 
 module Wbem
+
 class WsmanClient < WbemClient
 private
   #
@@ -221,13 +70,32 @@ private
 #    STDERR.puts "Return #{doc.to_xml}"
     doc
   end
+  #
+  # Get Wbem::Instance by EndPointReference
+  #
+  def get_by_epr epr
+    options = Openwsman::ClientOptions.new
+    options.set_dump_request if Wbem.debug
+#    puts "***\t@client.get_by_epr #{epr.GroupComponent}\n"
+    doc = @client.get_from_epr( options, epr )
+    unless doc
+      raise RuntimeError.new "Identify failed: HTTP #{@client.response_code}, Err #{@client.last_error}:#{@client.fault_string}"
+    end
+    puts doc.to_xml if Wbem.debug
+    if doc.fault?
+      raise Openwsman::Fault.new(doc).to_s
+    end
+    klass = factory.class_for epr.classname
+    klass.new self, epr, doc
+  end
+
 public
   attr_reader :client
 
   def initialize uri, auth_scheme = nil
     super uri, auth_scheme
     @url.path = "/wsman" if @url.path.nil? || @url.path.empty?
-#    Openwsman::debug = -1
+    Openwsman::debug = -1 if Wbem.debug
     STDERR.puts "WsmanClient connecting to #{uri}, auth #{@auth_scheme.inspect}" if Wbem.debug
 
     @client = Openwsman::Client.new @url.to_s
@@ -254,7 +122,7 @@ public
       raise "Unknown auth_scheme #{@auth_scheme.inspect}"
     end
     @options = Openwsman::ClientOptions.new
-    
+
 #    STDERR.puts "auth #{@auth_scheme.inspect} -> #{@client.transport.auth_method}"
 
     doc = _identify
@@ -356,7 +224,7 @@ public
       items = result.Items rescue nil
       if items
         items.each do |inst|
-          yield Openwsman::Instance.new(inst, self, uri)
+          yield Wbem::Instance.new(self, uri, inst)
         end
       end
       context = result.context
@@ -450,14 +318,13 @@ public
     else
       uri = epr_uri_for(namespace, classname)
     end
-    @options.flags = Openwsman::FLAG_ENUMERATION_ENUM_EPR # get EPRs
-    @options.flags = Openwsman::FLAG_ENUMERATION_OPTIMIZATION
+    @options.flags = Openwsman::FLAG_ENUMERATION_ENUM_EPR | Openwsman::FLAG_ENUMERATION_OPTIMIZATION
     @options.max_elements = 999
     @options.cim_namespace = namespace if @product == :openwsman
-    @options.set_dump_request
+    @options.set_dump_request if Wbem.debug
     @options.selectors = properties unless properties.empty?
     start = Time.now
-    STDERR.puts "instance_names enumerate (#{uri})"
+    STDERR.puts "instance_names enumerate (#{uri})" if Wbem.debug
     result = @client.enumerate( @options, nil, uri )
     names = []
     loop do
@@ -475,10 +342,33 @@ public
       break unless context
       result = @client.pull( @options, nil, uri, context )
     end
-    STDERR.puts "Enumerated #{names.size} items in #{Time.now-start} seconds"
+    STDERR.puts "Enumerated #{names.size} items in #{Time.now-start} seconds" if Wbem.debug
     return names
   end
 
+  #
+  # get instance by reference
+  #
+  # call-seq
+  #   get Openwsman::EndPointReference -> Wbem::Instance
+  #   get EndPointReference-as-String -> Wbem::Instance
+  #   get "ClassName", "key" => "value", :namespace => "root/interop"
+  #
+  def get instance_reference, keys = nil
+    if keys
+      uri = Openwsman.epr_uri_for "", instance_reference
+      instance_reference = Openwsman::EndPointReference.new(uri, nil, keys)
+    end
+    puts "@client.get #{instance_reference.class}..." if Wbem.debug
+    case instance_reference
+    when Openwsman::EndPointReference
+      get_by_epr instance_reference
+    when String
+      get_by_epr Openwsman::EndPointReference.new(instance_reference)
+    else
+      raise "Unsupported Wbem::get #{instance_reference.class}"
+    end
+  end
   #
   # Return matching Wbem::Instance for first instance
   #  matching namespace, classname, properties
@@ -503,14 +393,14 @@ public
     else
       uri = epr_uri_for(namespace, classname)
     end
-    @options.set_dump_request
+    @options.set_dump_request if Wbem.debug
     @options.cim_namespace = namespace if @product == :openwsman
     @options.selectors = properties unless properties.empty?
-    STDERR.puts "@client.get(namepace '#{@options.cim_namespace}', props #{properties.inspect}, uri #{uri}"
+    STDERR.puts "@client.get(namepace '#{@options.cim_namespace}', props #{properties.inspect}, uri #{uri}" if Wbem.debug
     res = @client.get(@options, uri)
     raise Openwsman::Exception.new res if res.fault?
-    Openwsman::Instance.new res, self, Openwsman::EndPointReference.new(uri, "", properties)
+    Wbem::Instance.new self, Openwsman::EndPointReference.new(uri, "", properties), res
   end
 
-end
-end # module
+end # class WsmanClient
+end # module Wbem