cmpi-bindings 0.5.0

data/lib/cmpi.rb

@@ -0,0 +1,344 @@
+#
+# cmpi.rb
+#
+# Main entry point for cmpi-bindings-ruby, Ruby based CIM Providers
+#
+
+class String
+  #
+  # Convert from CamelCase to under_score
+  #
+  def decamelize
+    self.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+	 gsub(/([a-z\d])([A-Z])/,'\1_\2').
+	 tr("-", "_").
+	 downcase
+  end
+end
+
+#
+# = Cmpi - Common Manageablity Programming Interface
+#
+
+# The Common Manageablity Programming Interface (CMPI) defines a
+# common standard of interfacing Manageability Instrumentation
+# (providers, instrumentation) to Management Brokers (CIM Object
+# Manager). The purpose of CMPI is to standardize Manageability
+# Instrumentation. This allows to write and build instrumentation once
+# and run it in different CIM environments (on one platform).
+#
+# == CIMOM Context
+#
+# == Provider Interface
+#
+
+module Cmpi
+
+  def self.null
+    0
+  end
+  def self.boolean
+    (2+0)
+  end
+  def self.char16
+    (2+1)
+  end
+
+  def self.real32
+    ((2+0)<<2)
+  end
+  def self.real64
+    ((2+1)<<2)
+  end
+
+  def self.uint8
+    ((8+0)<<4)
+  end
+  def self.uint16
+    ((8+1)<<4)
+  end
+  def self.uint32
+    ((8+2)<<4)
+  end
+  def self.uint64
+    ((8+3)<<4)
+  end
+  def self.sint8
+    ((8+4)<<4)
+  end
+  def self.sint16
+    ((8+5)<<4)
+  end
+  def self.sint32
+    ((8+6)<<4)
+  end
+  def self.sint64
+    ((8+7)<<4)
+  end
+  def self.instance
+    ((16+0)<<8)
+  end
+  def self.ref
+    ((16+1)<<8)
+  end
+  def self.args
+    ((16+2)<<8)
+  end
+  def self.filter
+    ((16+4)<<8)
+  end
+  def self.enumeration
+    ((16+5)<<8)
+  end
+  def self.string
+    ((16+6)<<8)
+  end
+  def self.chars
+    ((16+7)<<8)
+  end
+  def self.dateTime
+    ((16+8)<<8)
+  end
+  def self.ptr
+    ((16+9)<<8)
+  end
+  def self.charsptr
+    ((16+10)<<8)
+  end
+  
+  unless defined? CMPI_ARRAY
+    CMPI_ARRAY = ((1)<<13)
+  end
+
+  def self.booleanA
+    CMPI_ARRAY | self.boolean
+  end
+  def self.char16A
+    CMPI_ARRAY | self.char16
+  end
+
+  def self.real32A
+    CMPI_ARRAY | self.real32
+  end
+  def self.real64A
+    CMPI_ARRAY | self.real64
+  end
+
+  def self.uint8A
+    CMPI_ARRAY | self.uint8
+  end
+  def self.uint16A
+    CMPI_ARRAY | self.uint16
+  end
+  def self.uint32A
+    CMPI_ARRAY | self.uint32
+  end
+  def self.uint64A
+    CMPI_ARRAY | self.uint64
+  end
+  def self.sint8A
+    CMPI_ARRAY | self.sint8
+  end
+  def self.sint16A
+    CMPI_ARRAY | self.sint16
+  end
+  def self.sint32A
+    CMPI_ARRAY | self.sint32
+  end
+  def self.sint64A
+    CMPI_ARRAY | self.sint64
+  end
+  def self.instanceA
+    CMPI_ARRAY | self.instance
+  end
+  def self.refA
+    CMPI_ARRAY | self.ref
+  end
+  def self.argsA
+    CMPI_ARRAY | self.args
+  end
+  def self.filterA
+    CMPI_ARRAY | self.filter
+  end
+  def self.enumerationA
+    CMPI_ARRAY | self.enumeration
+  end
+  def self.stringA
+    CMPI_ARRAY | self.string
+  end
+  def self.charsA
+    CMPI_ARRAY | self.chars
+  end
+  def self.dateTimeA
+    CMPI_ARRAY | self.dateTime
+  end
+  def self.ptrA
+    CMPI_ARRAY | self.ptr
+  end
+  def self.charsptrA
+    CMPI_ARRAY | self.charsptrA
+  end
+
+  #
+  # Base class for ValueMap/Values classes from genprovider
+  #
+  class ValueMap
+    def self.method_missing name, *args
+      v = self.map[name.to_s]
+      return v if v
+      STDERR.puts "#{self.class}.#{name} ?"
+      nil
+    end
+  end
+  #
+  # CMPIContext gives the context for Provider operation
+  #
+  class CMPIContext
+    def count
+      #can't use alias here because CMPIContext::get_entry_count is only defined after
+      # initializing the provider (swig init code)
+      get_entry_count
+    end
+    def [] at
+      if at.kind_of? Integer
+	get_entry_at( at )
+      else
+	get_entry( at.to_s )
+      end
+    end
+    def each
+      0.upto(self.count-1) do |i|
+	yield get_entry_at(i)
+      end
+    end
+  end
+  
+  #
+  # CMPIInstance
+  #
+  class CMPIInstance
+    attr_accessor :typemap
+    def each
+      (0..size-1).each do |i|
+	yield self.get_property_at(i)
+      end
+    end
+    def to_s
+      path = objectpath
+      keys = []
+      path.each { |val,name| keys << name }
+      s = ""
+      self.each do |value,name|
+	next unless value
+	next if keys.include? name
+	s << ", " unless s.empty?
+	s << "\"#{name}\"=>#{value.inspect}"
+      end
+      "#{path} #{s}"
+    end
+    #
+    # Allow Instance.Property and Instance.Property=
+    #
+    def method_missing name, *args
+      s = name.to_s
+      if s =~ /=$/
+	v = args[0]
+	n = s.chop
+	# -> http://blog.sidu.in/2008/02/loading-classes-from-strings-in-ruby.html
+	@typemap ||= Cmpi.const_get(self.objectpath.classname).typemap
+	t = @typemap[n] if @typemap
+#	STDERR.puts "Instance.#{n} = #{v}:#{t}"
+        self[n,v] = t
+      else
+#	STDERR.puts "CMPIInstance.#{name} -> #{self[s].inspect}"
+	self[s]
+      end
+    end
+  end
+  
+  #
+  # CMPIObjectPath
+  #
+  class CMPIObjectPath
+    attr_accessor :typemap
+    #
+    # Allow Ref.Property and Ref.Property=
+    #
+    def method_missing name, *args
+      s = name.to_s
+      if s =~ /=$/
+	v = args[0]
+	n = s.chop
+	# -> http://blog.sidu.in/2008/02/loading-classes-from-strings-in-ruby.html
+	@typemap ||= Cmpi.const_get(classname).typemap rescue nil
+	t = @typemap[n] if @typemap
+#	STDERR.puts "ObjectPath.#{n} = #{v}:#{t}"
+        self[n,v] = t
+      else
+#	STDERR.puts "CMPIObjectPath.#{name} -> #{self[s].inspect}"
+	self[s]
+      end
+    end
+  end
+  
+  #
+  # CMPIEnumeration
+  #
+  class CMPIEnumeration
+    def each
+      while has_next
+	yield next_element
+      end
+    end
+  end
+  
+  #
+  # CMPIData
+  #
+  class CMPIData
+    def method_missing name, *args
+#      STDERR.puts "CMPIData.%s? %0x" % [name, type]
+      case type
+      when Cmpi.instance
+	value.inst.send(name,*args)
+      when Cmpi.ref
+	value.ref.send(name,*args)
+      end
+    end
+  end
+  
+  #
+  # CMPIStatus
+  #
+  class CMPIStatus
+    def to_s
+      (rc == 0) ? "Ok" : "#{rc}:#{msg}"
+    end
+  end
+  
+  #
+  # CMPIArgs
+  #
+  class CMPIArgs
+    def each
+      0.upto(size-1) do |i|
+	yield get_arg_at(i)
+      end
+    end
+    def to_hash
+      h = {}
+      each do |name,val|
+	h[name] = val
+      end
+      h
+    end
+    def to_s
+      s = ""
+      each do |name,val|
+	s << ", " unless s.empty?
+	s << "#{name.inspect} => #{val}"
+      end
+      "{ #{s} }"
+    end
+  end
+end

data/lib/cmpi/provider.rb

@@ -0,0 +1,213 @@
+#
+# provider.rb
+#
+# Provider API for cmpi-bindings-ruby, Ruby based CIM Providers
+#
+
+require 'cmpi'
+
+module Cmpi
+
+  #
+  # Accessor for broker value passed at provider initialization
+  #  Required internally for callbacks like CMNewString
+  #
+private
+  def self.broker= broker
+    @@broker = broker
+  end
+public
+  def self.broker
+    @@broker
+  end
+  def not_implemented klass, name
+    STDERR.puts "#{klass}.#{name}: not implemented"
+    nil
+  end
+  
+  #
+  # = Generic Provider interface
+  #
+  # Defines the interface common to all specific providers
+  # * InstanceProvider
+  # * MethodProvider
+  # * AssociationProvider
+  # * IndicationProvider
+  #
+  # define MI provider interfaces as modules
+  # so they can be used as mixins
+  #
+  # Typing information about interface function parameters
+  #
+  # context : CMPIContext
+  # result : CMPIResult
+  # reference : CMPIObjectPath
+  # properties : Array of String
+  #
+  module ProviderIF
+    protected
+    #
+    # call-seq:
+    #   ProviderIF.new broker
+    #
+    def initialize broker
+      Cmpi::broker = broker
+    end
+    #
+    # Cleanup provider, +terminating+: boolean
+    #
+    def cleanup context, terminating
+    end
+    def self.method_missing method, *args
+      not_implemented self.class, self.method
+    end
+  end
+  
+  #
+  # = Instance provider interface
+  #
+  # Defines the CMPI interface for Instance providers
+  #
+  # newinst : CMPIInstance
+  #
+  module InstanceProviderIF
+    protected
+    def create_instance context, result, reference, newinst
+    end
+    def enum_instance_names context, result, reference
+    end
+    def enum_instances context, result, reference, properties
+    end
+    def get_instance context, result, reference, properties
+    end
+    def set_instance context, result, reference, newinst, properties
+    end
+    def delete_instance context, result, reference
+    end
+    # query : String
+    # lang : String 
+    def exec_query context, result, reference, query, lang
+    end
+  end
+
+  #
+  # = Method provider interface
+  #
+  # Defines the CMPI interface for Method providers
+  #
+  #
+  module MethodProviderIF
+    protected
+    # method : String
+    # inargs : CMPIArgs
+    # outargs : CMPIArgs
+    def invoke_method context, result, reference, method, inargs, outargs
+    end
+  end
+  
+  #
+  # = Association provider interface
+  #
+  # Defines the CMPI interface for Association providers
+  #
+  #
+  # Typing information about interface function parameters
+  #
+  # assoc_class : String
+  # result_class : String
+  # role : String
+  # result_role : String
+  #
+  module AssociationProviderIF
+    protected
+    def associator_names context, result, reference, assoc_class, result_class, role, result_role
+    end
+    def associators context, result, reference, assoc_class, result_class, role, result_role, properties
+    end
+    def reference_names context, result, reference, result_class, role
+    end
+    def references context, result, reference, result_class, role, properties
+    end
+  end
+  
+  #
+  # = Indication provider interface
+  #
+  # Defines the CMPI interface for Indication providers
+  #
+  # Typing information about interface function parameters
+  #
+  # filter : CMPISelectExp
+  # class_name : String
+  # owner : String
+  # first_activation : Bool
+  # last_activation : Bool
+  #
+  module IndicationProviderIF
+    protected
+    def authorize_filter context, filter, class_name, reference, owner
+    end
+    def activate_filter context, filter, class_name, reference, first_activation
+    end
+    def deactivate_filter context, filter, class_name, reference, last_activation
+    end
+    def must_poll context, filter, class_name, reference
+    end
+    def enable_indications context
+    end
+    def disable_indications context
+    end
+  end
+
+  #
+  # = Instance Provider
+  #
+  # *Abstract* class
+  #
+  # == Synopsis
+  #   class MyProvider < Cmpi::InstanceProvider
+  #   end
+  #
+  # Handling instances of CIM classes
+  #
+  class InstanceProvider
+    include ProviderIF
+    include InstanceProviderIF
+  end
+  #
+  # = Method Provider
+  #
+  # *Abstract* class
+  #
+  # Implementing methods for classes and instances
+  #
+  # 
+  #
+  class MethodProvider
+    include ProviderIF
+    include MethodProviderIF
+  end
+  #
+  # = Association Provider
+  #
+  # *Abstract* class
+  #
+  # Providing (instances of) associations between instances
+  #
+  class AssociationProvider
+    include ProviderIF
+    include AssociationProviderIF
+  end
+  #
+  # = Indication Provider
+  #
+  # *Abstract* class
+  #
+  # Providing asynchronous events
+  #
+  class IndicationProvider
+    include ProviderIF
+    include IndicationProviderIF
+  end
+
+end