sfcc 0.1.0

data/ext/sfcc/sfcc.c

@@ -0,0 +1,344 @@
+
+#include <stdarg.h>
+
+#include "sfcc.h"
+
+#include <CimClientLib/cmci.h>
+#include <CimClientLib/native.h>
+#include <CimClientLib/cmcimacs.h>
+
+#include "cim_string.h"
+#include "cim_object_path.h"
+#include "cim_enumeration.h"
+#include "cim_class.h"
+#include "cim_instance.h"
+#include "cim_client.h"
+
+VALUE mSfcc;
+VALUE mSfccCim;
+
+void Init_sfcc()
+{
+  /**
+   * SBLIM sfcc ruby API
+   */
+  mSfcc = rb_define_module("Sfcc");
+  /**
+   * SBLIM sfcc CIMC API
+   */
+  mSfccCim= rb_define_module_under(mSfcc, "Cim");
+
+  init_cim_string();
+  init_cim_object_path();
+  init_cim_enumeration();
+  init_cim_class();
+  init_cim_instance();
+  init_cim_client();
+}
+
+static VALUE sfcc_status_exception(CMPIStatus status)
+{
+  switch (status.rc)
+  {
+  case CMPI_RC_ERR_FAILED:
+    return rb_const_get(mSfccCim, rb_intern("ErrorFailed"));
+  case CMPI_RC_ERR_ACCESS_DENIED:
+    return rb_const_get(mSfccCim, rb_intern("ErrorAcessDenied"));
+  case CMPI_RC_ERR_INVALID_NAMESPACE:
+    return rb_const_get(mSfccCim, rb_intern("ErrorInvalidNamespace"));
+  case CMPI_RC_ERR_INVALID_PARAMETER:
+    return rb_const_get(mSfccCim, rb_intern("ErrorInvalidParameter"));
+  case CMPI_RC_ERR_INVALID_CLASS:
+    return rb_const_get(mSfccCim, rb_intern("ErrorInvalidClass"));
+  case CMPI_RC_ERR_NOT_FOUND:
+    return rb_const_get(mSfccCim, rb_intern("ErrorNotFound"));
+  case CMPI_RC_ERR_NOT_SUPPORTED:
+    return rb_const_get(mSfccCim, rb_intern("ErrorNotSupported"));
+  case CMPI_RC_ERR_CLASS_HAS_CHILDREN:
+    return rb_const_get(mSfccCim, rb_intern("ErrorClassHasChildren"));
+  case CMPI_RC_ERR_CLASS_HAS_INSTANCES:
+    return rb_const_get(mSfccCim, rb_intern("ErrorClassHasInstances"));
+  case CMPI_RC_ERR_INVALID_SUPERCLASS:
+    return rb_const_get(mSfccCim, rb_intern("ErrorInvalidSuperClass"));
+  case CMPI_RC_ERR_ALREADY_EXISTS:
+    return rb_const_get(mSfccCim, rb_intern("ErrorAlreadyExists"));
+  case CMPI_RC_ERR_NO_SUCH_PROPERTY:
+    return rb_const_get(mSfccCim, rb_intern("ErrorNoSuchProperty"));
+  case CMPI_RC_ERR_TYPE_MISMATCH:
+    return rb_const_get(mSfccCim, rb_intern("ErrorTypeMismatch"));
+  case CMPI_RC_ERR_QUERY_LANGUAGE_NOT_SUPPORTED:
+    return rb_const_get(mSfccCim, rb_intern("ErrorQueryLanguageNotSupported"));
+  case CMPI_RC_ERR_INVALID_QUERY:
+    return rb_const_get(mSfccCim, rb_intern("ErrorInvalidQuery"));
+  case CMPI_RC_ERR_METHOD_NOT_AVAILABLE:
+    return rb_const_get(mSfccCim, rb_intern("ErrorMethodNotAvailable"));
+  case CMPI_RC_ERR_METHOD_NOT_FOUND:
+    return rb_const_get(mSfccCim, rb_intern("ErrorMethodNotFound"));
+  case CMPI_RC_DO_NOT_UNLOAD:
+    return rb_const_get(mSfccCim, rb_intern("ErrorDoNotUnload"));
+  case CMPI_RC_NEVER_UNLOAD:
+    return rb_const_get(mSfccCim, rb_intern("ErrorNeverUnload"));
+  case CMPI_RC_ERROR_SYSTEM:
+    return rb_const_get(mSfccCim, rb_intern("ErrorSystem"));
+  case CMPI_RC_ERROR:
+    return rb_const_get(mSfccCim, rb_intern("ErrorRcError"));
+  case CMPI_RC_OK:
+  default:
+    return Qnil;
+  }
+}
+
+void sfcc_rb_raise_if_error(CMPIStatus status, const char *msg, ...)
+{
+  static char *error_separator = " : ";
+  va_list arg_list;
+  va_start(arg_list, msg);
+  size_t size = 0;
+  char *error = NULL;
+
+  if (!status.rc)
+    return;
+
+  size = sizeof(msg) + sizeof(error_separator);
+  if (status.msg)
+    size = size + sizeof(status.msg->ft->getCharPtr(status.msg, NULL));
+  error = (char *)malloc(size*sizeof(char *));
+  strcpy(error, msg);
+  if (status.msg) {
+    strcat(error, " : ");
+    strcat(error, status.msg->ft->getCharPtr(status.msg, NULL));
+  }
+  rb_raise(sfcc_status_exception(status), error, arg_list);
+  free(error);
+}
+
+char ** sfcc_value_array_to_string_array(VALUE array)
+{
+  char **ret;
+  int i = 0;
+
+  if ( !NIL_P(array) && RARRAY_LEN(array) > 0 ) {
+    ret = (char**) malloc(RARRAY_LEN(array)*sizeof(char*));
+    for (; i < RARRAY_LEN(array); ++i)
+      ret[i] = StringValuePtr(*(RARRAY_PTR(array) + i));
+  }
+  else
+    ret = NULL;
+
+  return ret;
+}
+
+VALUE sfcc_cimdata_to_value(CMPIData data)
+{
+  CMPIString *cimstr = NULL;
+  VALUE rbval;
+  CMPIStatus status;
+
+  if (data.type & CMPI_ARRAY) {
+    int k = 0;
+    int n = 0;
+    VALUE rbarray = rb_ary_new();
+
+    if (!data.value.array)
+      return rb_ary_new();
+
+    n = data.value.array->ft->getSize(data.value.array, &status);
+    if (!status.rc) {
+      for (k = 0; k < n; ++k) {
+        CMPIData element = data.value.array->ft->getElementAt(data.value.array, k, NULL);
+        rb_ary_push(rbarray, sfcc_cimdata_to_value(element));
+      }
+      return rbarray;
+    }
+    sfcc_rb_raise_if_error(status, "Can't retrieve array size");
+    return Qnil;
+  }
+  else if (data.type & CMPI_ENC) {    
+    switch (data.type) {
+    case CMPI_instance:
+      return data.value.inst ? Sfcc_wrap_cim_instance(data.value.inst->ft->clone(data.value.inst, NULL)) : Qnil;
+    case CMPI_class:
+      return data.value.cls ? Sfcc_wrap_cim_class(data.value.cls->ft->clone(data.value.cls, NULL)) : Qnil;
+    case CMPI_ref:
+      return data.value.ref ? Sfcc_wrap_cim_object_path(data.value.ref->ft->clone(data.value.ref, NULL)) : Qnil;
+    case CMPI_args:      
+      return data.value.args ? sfcc_cimargs_to_hash(data.value.args) : Qnil;
+    case CMPI_filter:
+      return Qnil;
+    case CMPI_numericString:
+    case CMPI_booleanString:
+    case CMPI_dateTimeString:
+    case CMPI_classNameString:
+      break;
+    case CMPI_string:
+      return data.value.string ? rb_str_new2((char*)data.value.string->ft->getCharPtr(data.value.string, NULL)) : Qnil;
+    case CMPI_charsptr:
+      return data.value.chars ? rb_str_new((char*)data.value.dataPtr.ptr, data.value.dataPtr.length) : Qnil;
+    case CMPI_dateTime:
+      cimstr = data.value.dateTime ? CMGetStringFormat(data.value.dateTime,NULL) : NULL;
+      rbval = cimstr ? rb_str_new2(cimstr->ft->getCharPtr(cimstr, NULL)) : Qnil;
+      if (cimstr) CMRelease(cimstr);
+      return rbval;
+    }
+  }
+  else if (data.type & CMPI_SIMPLE) {
+    switch (data.type) {
+    case CMPI_boolean: return data.value.boolean ? Qtrue : Qfalse;
+    case CMPI_char16: return UINT2NUM(data.value.char16);
+    }
+  }
+  else if (data.type & CMPI_INTEGER) {
+    switch (data.type) {
+    case CMPI_uint8: return UINT2NUM(data.value.uint8);
+    case CMPI_sint8: return INT2NUM(data.value.sint8);
+    case CMPI_uint16: return UINT2NUM(data.value.uint16);
+    case CMPI_sint16: return INT2NUM(data.value.sint16);
+    case CMPI_uint32: return UINT2NUM(data.value.uint32);
+    case CMPI_sint32: return INT2NUM(data.value.sint32);
+    case CMPI_uint64: return UINT2NUM(data.value.uint64);
+    case CMPI_sint64: return INT2NUM(data.value.sint64);
+    }
+  }
+  else if (data.type & CMPI_REAL) {
+    switch (data.type) {
+    case CMPI_real32: return LONG2NUM(data.value.real32);
+    case CMPI_real64: return LONG2NUM(data.value.real64);
+    }
+  }
+  else if (data.type & CMPI_null ) {
+    return Qnil;
+  }
+  rb_raise(rb_eTypeError, "unsupported data data type %d", data.type);
+  return Qnil;
+}
+
+/* callback to add each hash element to a CMPIArgs */
+static int hash_to_cimargs_iterator(VALUE key, VALUE value, VALUE extra)
+{
+  CMPIStatus status;
+  CMPIData data;
+  CMPIArgs *args = (CMPIArgs *)extra;
+  VALUE key_str = rb_funcall(key, rb_intern("to_s"), 0);
+  char *key_cstr = StringValuePtr(key_str);
+  data = sfcc_value_to_cimdata(value);
+  status = args->ft->addArg(args, key_cstr, &data.value, data.type);
+
+  if ( !status.rc ) {
+    return ST_CONTINUE;
+  }
+
+  sfcc_rb_raise_if_error(status, "Can't add argument '%s'", StringValuePtr(key));
+  return ST_STOP;
+}
+
+CMPIArgs *sfcc_hash_to_cimargs(VALUE hash)
+{
+  CMPIArgs *args;
+  args = newCMPIArgs(NULL);
+  rb_hash_foreach(hash, hash_to_cimargs_iterator, (VALUE)args);
+  return args;
+}
+
+VALUE sfcc_cimargs_to_hash(CMPIArgs *args)
+{
+  CMPIArgs *ptr = NULL;
+  int i = 0;
+  int n = 0;
+  VALUE hash;
+  CMPIString *argname;
+  CMPIData argdata;
+  CMPIStatus status;
+  char *argname_cstr = NULL;
+
+  //Data_Get_Struct(args, CMPIArgs, ptr);
+  ptr = args;
+  if (!ptr) {
+    rb_raise(rb_eRuntimeError, "Can't retrieve args pointer");
+    return Qnil;
+  }
+  n = ptr->ft->getArgCount(ptr, NULL);
+  hash = rb_hash_new();
+
+  for (; i < n; ++i) {
+    argname = NULL;
+    argdata = ptr->ft->getArgAt(ptr, i, &argname, &status);
+    if (!status.rc && argdata.state == CMPI_goodValue ) {
+      argname_cstr = argname->ft->getCharPtr(argname, &status);
+      if (!argname_cstr) {
+        rb_raise(rb_eRuntimeError, "Can't retrieve argument name");
+        return Qnil;
+      }
+
+      if (!status.rc) {
+        rb_hash_aset(hash, rb_funcall(rb_str_new2(argname_cstr), rb_intern("to_sym"), 0), sfcc_cimdata_to_value(argdata));
+      }
+      else {
+        sfcc_rb_raise_if_error(status, "Can't retrieve argument name");
+        return Qnil;
+      }
+    }
+    else {
+      sfcc_rb_raise_if_error(status, "Can't retrieve argument");
+      return Qnil;
+    }
+  }
+  return hash;
+}
+
+CMPIData sfcc_value_to_cimdata(VALUE value)
+{
+  CMPIData data;
+  memset(&data, 0, sizeof(CMPIData));
+  data.state = CMPI_goodValue;
+  data.type = CMPI_null;
+
+  switch (TYPE(value))
+  {
+  case T_NIL:
+    data.type = CMPI_null;
+    data.state = CMPI_nullValue;
+    break;
+  case T_STRING:
+    data.type = CMPI_string;
+    data.value.string = newCMPIString(StringValuePtr(value), NULL);
+    break;
+  case T_TRUE:
+    data.type = CMPI_boolean;
+    data.value.boolean = 1;
+    break;
+  case T_FALSE:
+    data.type = CMPI_boolean;
+    data.value.boolean = 0;
+    break;
+  case T_FIXNUM:
+    data.type = CMPI_sint64;
+    data.value.Long = NUM2INT(value);
+    break;
+/* not yet supported
+  case T_BIGNUM:       
+    break;
+  case T_FLOAT:
+    break;
+  case T_ARRAY:
+    break;
+  case T_HASH:
+    break;
+  case T_SYMBOL:
+    */
+  case T_DATA:
+  default:
+    if (CLASS_OF(value) == cSfccCimString) {
+      Data_Get_Struct(value, CMPIString, data.value.string);  
+      data.type = CMPI_string;
+    }
+    else {
+      data.state = CMPI_badValue;
+      data.type = CMPI_null;
+      VALUE cname = rb_funcall(rb_funcall(value, rb_intern("class"), 0), rb_intern("to_s"), 0);
+      const char *class_name = StringValuePtr(cname);
+      rb_raise(rb_eTypeError, "unsupported data data type: %s", class_name);
+      return data;
+    }
+  }
+  return data;
+}

data/ext/sfcc/sfcc.h

@@ -0,0 +1,87 @@
+
+#ifndef RUBY_SFCC_NATIVE
+#define RUBY_SFCC_NATIVE
+
+#include <assert.h>
+
+/*
+#include <cimc/cimc.h>
+#include <cimc/cimcdt.h>
+#include <cimc/cimcft.h>
+*/
+#include <CimClientLib/cmci.h>
+#include <CimClientLib/cmcidt.h>
+#include <CimClientLib/cmcift.h>
+#include <CimClientLib/native.h>
+#include <CimClientLib/cmcimacs.h>
+
+#include "ruby.h"
+#include "st.h"
+#include <unistd.h>
+#include <stdlib.h>
+
+extern VALUE mSfcc;
+extern VALUE mSfccCim;
+
+/*
+#define SFCC_DEC_REFCOUNT(x) \
+  do { \
+    int refc = ((CIMCObject*)x)->refCount; \
+    printf("dec X: %d rf: %d\n", (int)x, refc); \
+    --((CIMCObject*)x)->refCount;          \
+    if (refc <= 0) \
+      x->ft->release(x); \
+    free(x); \
+  } while (0);
+*/
+
+#define SFCC_DEC_REFCOUNT(x) \
+  x->ft->release(x);
+
+/*
+#define SFCC_INC_REFCOUNT(x) \
+  do { \
+    int refc = ((CIMCObject*)x)->refCount; \
+    printf("inc X: %d rf: %d\n", (int) x, refc); \
+    ++((CIMCObject*)x)->refCount;          \
+  } while (0);
+*/
+
+#define SFCC_INC_REFCOUNT(x) (void)(0);
+
+/**
+ * raises a ruby exception if the status is an error
+ * whenever possible, adds the custom message if not null
+ */
+void sfcc_rb_raise_if_error(CMPIStatus status, const char *msg, ...);
+
+/**
+ * allocates a string array where each string points to the
+ * str pointer of the value
+ *
+ * you need to deallocate the array yourself. But don't deallocate
+ * the elements.
+ */
+inline char ** sfcc_value_array_to_string_array(VALUE array);
+
+/**
+ * converts a ruby hash to a CIM args object
+ */
+inline CMPIArgs* sfcc_hash_to_cimargs(VALUE hash);
+
+/**
+ * converts a CIM args object to a hash
+ */
+inline VALUE sfcc_cimargs_to_hash(CMPIArgs *args);
+
+/**
+ * converts CMPIData to ruby VALUE
+ */
+inline VALUE sfcc_cimdata_to_value(CMPIData data);
+
+/**
+ * convert ruby VALUE to CMPIData
+ */
+inline CMPIData sfcc_value_to_cimdata(VALUE value);
+
+#endif

data/lib/sfcc.rb

@@ -0,0 +1,174 @@
+
+require "sfcc.so" # native
+require 'enumerator'
+require 'uri'
+
+module Sfcc
+
+  VERSION = "0.1.0"
+
+  module Flags
+    LocalOnly          = 1
+    DeepInheritance    = 2
+    IncludeQualifiers  = 4
+    IncludeClassOrigin = 8
+  end
+    
+  module Cim
+
+    # Base class for errors
+    class Error < RuntimeError; end
+  
+    # A general error occurred that is not covered by a more specific error code
+    class ErrorFailed < Sfcc::Cim::Error; end
+    # Access to a CIM resource was not available to the client
+    class ErrorAccessDenied < Sfcc::Cim::Error; end
+    # The target namespace does not exist
+    class ErrorInvalidNamespace < Sfcc::Cim::Error; end
+    # One or more parameter values passed to the method were invalid
+    class ErrorInvalidParameter < Sfcc::Cim::Error; end
+    # The specified Class does not exist
+    class ErrorInvalidClass < Sfcc::Cim::Error; end
+    # The requested object could not be found
+    class ErrorNotFound < Sfcc::Cim::Error; end
+    # The requested operation is not supported
+    class ErrorNotSupported < Sfcc::Cim::Error; end
+    # Operation cannot be carried out on this class since it has subclasses
+    class ErrorClassHasChildren < Sfcc::Cim::Error; end
+    # Operation cannot be carried out on this class since it has instances
+    class ErrorClassHasInstances < Sfcc::Cim::Error; end
+    # Operation cannot be carried out since the specified superclass does not exist
+    class ErrorInvalidSuperClass < Sfcc::Cim::Error; end
+    # Operation cannot be carried out because an object already exists
+    class ErrorAlreadyExists < Sfcc::Cim::Error; end
+    # The specified Property does not exist
+    class ErrorNoSuchProperty < Sfcc::Cim::Error; end
+    # The value supplied is incompatible with the type
+    class ErrorTypeMisMatch < Sfcc::Cim::Error; end
+    # The query language is not recognized or supported
+    class ErrorQueryLanguageNotSupported < Sfcc::Cim::Error; end
+    # The query is not valid for the specified query language
+    class ErrorInvalidQuery < Sfcc::Cim::Error; end
+    # The extrinsic Method could not be executed
+    class ErrorMethodNotAvailable < Sfcc::Cim::Error; end
+    # The specified extrinsic Method does not exist
+    class ErrorMethodNotFound < Sfcc::Cim::Error; end
+    
+    class ErrorDoNotUnload < RuntimeError; end
+    class ErrorErrorSystem < RuntimeError; end
+    class ErrorRcError < RuntimeError; end
+    
+    class Client
+      # Client.connect(:host => "localhost",
+      #                :scheme => "http",
+      #                :port => 5988,
+      #                :user => "root",
+      #                :password => "foo") do |client|
+      #   # do something with client
+      # end
+      #
+      # client is both returned and passed to the given block.
+      #
+      # Alternatively you can pass a uri:
+      #
+      # client = Client.connect(uri)
+      #
+      def self.connect(args={})
+        params = {}
+        uri = nil
+        case args
+        when Hash
+          params.merge!(args)
+        when String
+          uri = URI.parse(arg)
+        when URI
+          params[:host] = uri.host
+          params[:scheme] = uri.scheme
+          params[:port] = uri.port
+          params[:user] = uri.user
+          params[:password] = uri.password          
+        end
+
+        native_connect(params[:host],
+                       params[:scheme],
+                       params[:port],
+                       params[:user],
+                       params[:password]);
+      end
+    end
+
+    class Class
+      # properties => Hash
+      #
+      # return a hash with all properties
+      def properties
+        ret = {}
+        each_property { |key, value| ret[key] = value }
+        ret
+      end
+
+      # qualifiers => Hash
+      #
+      # return a hash with all qualifiers
+      def qualifiers
+        ret = {}
+        each_qualifier { |key, value| ret[key] = value }
+        ret
+      end
+
+      # property_qualifiers(property_name) => Hash
+      #
+      # return a hash with all qualifiers for +property_name+
+      def property_qualifiers(property_name)
+        ret = {}
+        each_property_qualifier(property_name) { |key, value| ret[key] = value }
+        ret
+      end
+
+    end
+    
+    class Instance
+      # properties => Hash
+      #
+      # return a hash with all properties
+      def properties
+        ret = {}
+        each_property { |key, value| ret[key] = value }
+        ret
+      end
+
+      # qualifiers => Hash
+      #
+      # return a hash with all qualifiers
+      def qualifiers
+        ret = {}
+        each_qualifier { |key, value| ret[key] = value }
+        ret
+      end
+
+      # property_qualifiers(property_name) => Hash
+      #
+      # return a hash with all qualifiers for +property_name+
+      def property_qualifiers(property_name)
+        ret = {}
+        each_property_qualifier(property_name) { |key, value| ret[key] = value }
+        ret
+      end
+      
+      # returns the string representation of
+      # the object path for this instance
+      def to_s
+        object_path.to_s
+      end
+    end
+
+    class ObjectPath
+    end
+
+    class Enumeration
+    end
+    
+  end
+  
+end
+

data/test/helper.rb

@@ -0,0 +1,32 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'tempfile'
+ 
+%w(../lib ../ext).each do |path|
+  $LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), path)))
+end
+ 
+require 'rubygems'
+require 'sfcc'
+ 
+class SfccTestCase < Test::Unit::TestCase
+  ASSETS = File.expand_path(File.join(File.dirname(__FILE__), 'assets'))
+ 
+  unless RUBY_VERSION >= '1.9'
+    undef :default_test
+  end
+
+  def cimom_running?
+    `ps -e`.each_line do |line|
+      return true if line =~ /sfcbd/
+    end
+    return false
+  end
+
+  def setup_cim_client
+    @client = Sfcc::Cim::Client.connect('http://root@localhost:5988')
+    # @client = Sfcc::Cim::Client.connect(:host => 'localhost', :scheme => 'http', :user => 'root', :port => '5988')
+  end
+  
+end

data/test/test_sfcc.rb

@@ -0,0 +1,69 @@
+require File.join(File.dirname(__FILE__), 'helper')
+require 'pp'
+
+class BasicTest < SfccTestCase
+
+  context "a running CIMOM with no auth" do
+    setup do
+      setup_cim_client
+    end
+
+    should "be running" do
+      assert cimom_running?
+    end
+
+    should "be of class Client" do
+      assert_kind_of(Sfcc::Cim::Client, @client)
+    end
+        
+    context "a new object path for root/cimv2" do
+      setup do
+        @op = Sfcc::Cim::ObjectPath.new("root/cimv2", "")
+      end
+      
+      should "be of class ObjectPath" do
+        assert_kind_of(Sfcc::Cim::ObjectPath, @op)
+      end
+      
+      should "allow for query" do
+        result = @client.query(@op, "select * from CIM_ComputerSystem", "wql")
+        result.each do |instance|
+          puts instance
+        end
+          end
+            
+      context "class names" do
+        setup do
+          @class_names = @client.class_names(@op, Sfcc::Flags::DeepInheritance)
+        end
+        
+        should "be a Cimc::Enumeration" do
+          assert_kind_of(Sfcc::Cim::Enumeration, @class_names)
+        end
+        
+        should "include CIM_ManagedElement" do
+          assert !@class_names.select { |x| x.to_s == "CIM_ManagedElement" }.empty?
+        end
+        
+        should "have every element of type Sfcc::Cim::ObjectPath" do
+          @class_names.each { |n| assert_kind_of(Sfcc::Cim::ObjectPath, n) }
+        end            
+      end
+      
+      context "classes" do
+        setup do
+          @classes = @client.classes(@op, Sfcc::Flags::DeepInheritance)
+        end
+        
+        should "be a Cimc::Enumeration" do
+          assert_kind_of(Sfcc::Cim::Enumeration, @classes)
+        end
+        
+        should "have every alement of type Cimc::Class" do
+          @classes.each { |c| assert_kind_of(Sfcc::Cim::Class, c) }
+        end            
+      end
+      
+    end
+  end  
+end