sfcc 0.1.2 → 0.5.0

data/ext/sfcc/cim_string.h

@@ -7,6 +7,6 @@
 void init_cim_string();
 
 extern VALUE cSfccCimString;
-VALUE Sfcc_wrap_cim_string(CMPIString *string);
+VALUE Sfcc_wrap_cim_string(CIMCString *string);
 
 #endif

data/ext/sfcc/extconf.rb

@@ -1,8 +1,12 @@
 require 'mkmf'
 # $CFLAGS = "#{$CFLAGS} -Werror"
 
-have_library('cmpisfcc', 'NewCIMCEnv')
-#find_header 'cimc.h', '/usr/include/cimc'
-find_header 'cmci.h', '/usr/include/CimClientLib'
-create_makefile('sfcc')
+unless have_library('cimcclient', 'NewCIMCEnv')
+  STDERR.puts "Cannot find NewCIMCEnv() in libcimcclient"
+  STDERR.puts "Is sblim-sfcc-devel installed ?"
+  exit 1
+end
 
+find_header 'cimc.h', '/usr/include/cimc'
+find_header 'cmcimacs.h', '/usr/include/CimClientLib'
+create_makefile('sfcc')

data/ext/sfcc/sfcc.c

@@ -3,10 +3,6 @@
 
 #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"
@@ -16,9 +12,23 @@
 
 VALUE mSfcc;
 VALUE mSfccCim;
+CIMCEnv *cimcEnv;
+
+static void
+Exit_sfcc(CIMCEnv *env)
+{
+/*  fprintf(stderr, "Sfcc_dealloc_cimcEnv %p\n", env); */
+  if (env) env->ft->release(env);
+}
 
 void Init_sfcc()
 {
+  const char *conn;
+  VALUE cEnvironment; /* class */
+  VALUE value; /* wrapped value */
+  int rc;
+  char *msg;
+
   /**
    * SBLIM sfcc ruby API
    */
@@ -28,6 +38,22 @@ void Init_sfcc()
    */
   mSfccCim= rb_define_module_under(mSfcc, "Cim");
 
+  /**
+   * alloc CimcEnvironment once, store as const
+   */
+  cEnvironment = rb_define_class_under(mSfccCim, "CimcEnvironment", rb_cObject);
+  conn = getenv("RUBY_SFCC_CONNECTION"); /* "SfcbLocal" or "XML" */
+  if (!conn) conn = "XML";
+  cimcEnv = NewCIMCEnv(conn,0,&rc,&msg);
+  if (!cimcEnv) {
+    rb_raise(rb_eLoadError, "Cannot local %s cim client library. %d:%s", conn, rc, msg ? msg : "");
+  }
+  value = Data_Wrap_Struct(cEnvironment, NULL, Exit_sfcc, cimcEnv);
+  rb_define_const(mSfccCim, "CIMC_ENV", value);
+
+  /**
+   * Init other sub-classes
+   */
   init_cim_string();
   init_cim_object_path();
   init_cim_enumeration();
@@ -36,53 +62,53 @@ void Init_sfcc()
   init_cim_client();
 }
 
-static VALUE sfcc_status_exception(CMPIStatus status)
+static VALUE sfcc_status_exception(CIMCStatus status)
 {
   switch (status.rc)
   {
-  case CMPI_RC_ERR_FAILED:
+  case CIMC_RC_ERR_FAILED:
     return rb_const_get(mSfccCim, rb_intern("ErrorFailed"));
-  case CMPI_RC_ERR_ACCESS_DENIED:
+  case CIMC_RC_ERR_ACCESS_DENIED:
     return rb_const_get(mSfccCim, rb_intern("ErrorAcessDenied"));
-  case CMPI_RC_ERR_INVALID_NAMESPACE:
+  case CIMC_RC_ERR_INVALID_NAMESPACE:
     return rb_const_get(mSfccCim, rb_intern("ErrorInvalidNamespace"));
-  case CMPI_RC_ERR_INVALID_PARAMETER:
+  case CIMC_RC_ERR_INVALID_PARAMETER:
     return rb_const_get(mSfccCim, rb_intern("ErrorInvalidParameter"));
-  case CMPI_RC_ERR_INVALID_CLASS:
+  case CIMC_RC_ERR_INVALID_CLASS:
     return rb_const_get(mSfccCim, rb_intern("ErrorInvalidClass"));
-  case CMPI_RC_ERR_NOT_FOUND:
+  case CIMC_RC_ERR_NOT_FOUND:
     return rb_const_get(mSfccCim, rb_intern("ErrorNotFound"));
-  case CMPI_RC_ERR_NOT_SUPPORTED:
+  case CIMC_RC_ERR_NOT_SUPPORTED:
     return rb_const_get(mSfccCim, rb_intern("ErrorNotSupported"));
-  case CMPI_RC_ERR_CLASS_HAS_CHILDREN:
+  case CIMC_RC_ERR_CLASS_HAS_CHILDREN:
     return rb_const_get(mSfccCim, rb_intern("ErrorClassHasChildren"));
-  case CMPI_RC_ERR_CLASS_HAS_INSTANCES:
+  case CIMC_RC_ERR_CLASS_HAS_INSTANCES:
     return rb_const_get(mSfccCim, rb_intern("ErrorClassHasInstances"));
-  case CMPI_RC_ERR_INVALID_SUPERCLASS:
+  case CIMC_RC_ERR_INVALID_SUPERCLASS:
     return rb_const_get(mSfccCim, rb_intern("ErrorInvalidSuperClass"));
-  case CMPI_RC_ERR_ALREADY_EXISTS:
+  case CIMC_RC_ERR_ALREADY_EXISTS:
     return rb_const_get(mSfccCim, rb_intern("ErrorAlreadyExists"));
-  case CMPI_RC_ERR_NO_SUCH_PROPERTY:
+  case CIMC_RC_ERR_NO_SUCH_PROPERTY:
     return rb_const_get(mSfccCim, rb_intern("ErrorNoSuchProperty"));
-  case CMPI_RC_ERR_TYPE_MISMATCH:
+  case CIMC_RC_ERR_TYPE_MISMATCH:
     return rb_const_get(mSfccCim, rb_intern("ErrorTypeMismatch"));
-  case CMPI_RC_ERR_QUERY_LANGUAGE_NOT_SUPPORTED:
+  case CIMC_RC_ERR_QUERY_LANGUAGE_NOT_SUPPORTED:
     return rb_const_get(mSfccCim, rb_intern("ErrorQueryLanguageNotSupported"));
-  case CMPI_RC_ERR_INVALID_QUERY:
+  case CIMC_RC_ERR_INVALID_QUERY:
     return rb_const_get(mSfccCim, rb_intern("ErrorInvalidQuery"));
-  case CMPI_RC_ERR_METHOD_NOT_AVAILABLE:
+  case CIMC_RC_ERR_METHOD_NOT_AVAILABLE:
     return rb_const_get(mSfccCim, rb_intern("ErrorMethodNotAvailable"));
-  case CMPI_RC_ERR_METHOD_NOT_FOUND:
+  case CIMC_RC_ERR_METHOD_NOT_FOUND:
     return rb_const_get(mSfccCim, rb_intern("ErrorMethodNotFound"));
-  case CMPI_RC_DO_NOT_UNLOAD:
+  case CIMC_RC_DO_NOT_UNLOAD:
     return rb_const_get(mSfccCim, rb_intern("ErrorDoNotUnload"));
-  case CMPI_RC_NEVER_UNLOAD:
+  case CIMC_RC_NEVER_UNLOAD:
     return rb_const_get(mSfccCim, rb_intern("ErrorNeverUnload"));
-  case CMPI_RC_ERROR_SYSTEM:
+  case CIMC_RC_ERROR_SYSTEM:
     return rb_const_get(mSfccCim, rb_intern("ErrorSystem"));
-  case CMPI_RC_ERROR:
+  case CIMC_RC_ERROR:
     return rb_const_get(mSfccCim, rb_intern("ErrorRcError"));
-  case CMPI_RC_OK:
+  case CIMC_RC_OK:
   default:
     return Qnil;
   }
@@ -90,7 +116,7 @@ static VALUE sfcc_status_exception(CMPIStatus status)
 
 #define MAX_ERROR_BUFFER 255
 
-void sfcc_rb_raise_if_error(CMPIStatus status, const char *msg, ...)
+void sfcc_rb_raise_if_error(CIMCStatus status, const char *msg, ...)
 {
   va_list arg_list;
   char orig_error[MAX_ERROR_BUFFER];
@@ -103,8 +129,10 @@ void sfcc_rb_raise_if_error(CMPIStatus status, const char *msg, ...)
   vsnprintf(orig_error, MAX_ERROR_BUFFER, msg, arg_list);
   va_end(arg_list);
 
-  if (status.msg)
+  if (status.msg) {
     snprintf(error, MAX_ERROR_BUFFER, "%s : %s", orig_error, status.msg->ft->getCharPtr(status.msg, NULL));
+    CMRelease(status.msg);
+  }
   else
     strcpy(error, orig_error);
 
@@ -119,7 +147,7 @@ char ** sfcc_value_array_to_string_array(VALUE array)
   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));
+      ret[i] = (char *)to_charptr(*(RARRAY_PTR(array) + i));
   }
   else
     ret = NULL;
@@ -127,13 +155,13 @@ char ** sfcc_value_array_to_string_array(VALUE array)
   return ret;
 }
 
-VALUE sfcc_cimdata_to_value(CMPIData data)
+VALUE sfcc_cimdata_to_value(CIMCData data)
 {
-  CMPIString *cimstr = NULL;
+  CIMCString *cimstr = NULL;
   VALUE rbval;
-  CMPIStatus status;
+  CIMCStatus status;
 
-  if (data.type & CMPI_ARRAY) {
+  if (data.type & CIMC_ARRAY) {
     int k = 0;
     int n = 0;
     VALUE rbarray = rb_ary_new();
@@ -144,7 +172,7 @@ VALUE sfcc_cimdata_to_value(CMPIData data)
     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);
+        CIMCData element = data.value.array->ft->getElementAt(data.value.array, k, NULL);
         rb_ary_push(rbarray, sfcc_cimdata_to_value(element));
       }
       return rbarray;
@@ -152,59 +180,64 @@ VALUE sfcc_cimdata_to_value(CMPIData data)
     sfcc_rb_raise_if_error(status, "Can't retrieve array size");
     return Qnil;
   }
-  else if (data.type & CMPI_ENC) {    
+  else if (data.type & CIMC_ENC) {
     switch (data.type) {
-    case CMPI_instance:
+    case CIMC_instance:
       return data.value.inst ? Sfcc_wrap_cim_instance(data.value.inst->ft->clone(data.value.inst, NULL)) : Qnil;
-    case CMPI_class:
+    case CIMC_class:
       return data.value.cls ? Sfcc_wrap_cim_class(data.value.cls->ft->clone(data.value.cls, NULL)) : Qnil;
-    case CMPI_ref:
+    case CIMC_ref:
       return data.value.ref ? Sfcc_wrap_cim_object_path(data.value.ref->ft->clone(data.value.ref, NULL)) : Qnil;
-    case CMPI_args:      
+    case CIMC_args:
       return data.value.args ? sfcc_cimargs_to_hash(data.value.args) : Qnil;
-    case CMPI_filter:
+    case CIMC_filter:
       return Qnil;
-    case CMPI_numericString:
-    case CMPI_booleanString:
-    case CMPI_dateTimeString:
-    case CMPI_classNameString:
+    case CIMC_numericString:
+    case CIMC_booleanString:
+    case CIMC_dateTimeString:
+    case CIMC_classNameString:
       break;
-    case CMPI_string:
+    case CIMC_string:
       return data.value.string ? rb_str_new2((char*)data.value.string->ft->getCharPtr(data.value.string, NULL)) : Qnil;
-    case CMPI_charsptr:
+    case CIMC_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);
+    case CIMC_dateTime:
+      if (data.value.dateTime) {
+        CIMCUint64 bintime;
+        bintime = data.value.dateTime->ft->getBinaryFormat(data.value.dateTime, NULL);
+        rbval = rb_time_new((time_t) (bintime / 1000000L), (time_t) (bintime % 1000000));
+      }
+      else {
+        rbval = Qnil;
+      }
       return rbval;
     }
   }
-  else if (data.type & CMPI_SIMPLE) {
+  else if (data.type & CIMC_SIMPLE) {
     switch (data.type) {
-    case CMPI_boolean: return data.value.boolean ? Qtrue : Qfalse;
-    case CMPI_char16: return UINT2NUM(data.value.char16);
+    case CIMC_boolean: return data.value.boolean ? Qtrue : Qfalse;
+    case CIMC_char16: return UINT2NUM(data.value.char16);
     }
   }
-  else if (data.type & CMPI_INTEGER) {
+  else if (data.type & CIMC_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);
+    case CIMC_uint8: return UINT2NUM(data.value.uint8);
+    case CIMC_sint8: return INT2NUM(data.value.sint8);
+    case CIMC_uint16: return UINT2NUM(data.value.uint16);
+    case CIMC_sint16: return INT2NUM(data.value.sint16);
+    case CIMC_uint32: return UINT2NUM(data.value.uint32);
+    case CIMC_sint32: return INT2NUM(data.value.sint32);
+    case CIMC_uint64: return UINT2NUM(data.value.uint64);
+    case CIMC_sint64: return INT2NUM(data.value.sint64);
     }
   }
-  else if (data.type & CMPI_REAL) {
+  else if (data.type & CIMC_REAL) {
     switch (data.type) {
-    case CMPI_real32: return LONG2NUM(data.value.real32);
-    case CMPI_real64: return LONG2NUM(data.value.real64);
+    case CIMC_real32: return rb_float_new(data.value.real32);
+    case CIMC_real64: return rb_float_new(data.value.real64);
     }
   }
-  else if (data.type & CMPI_null ) {
+  else if (data.type & CIMC_null ) {
     return Qnil;
   }
   rb_raise(rb_eTypeError, "unsupported data data type %d", data.type);
@@ -214,11 +247,11 @@ VALUE sfcc_cimdata_to_value(CMPIData data)
 /* 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;
+  CIMCStatus status;
+  CIMCData data;
+  CIMCArgs *args = (CIMCArgs *)extra;
   VALUE key_str = rb_funcall(key, rb_intern("to_s"), 0);
-  char *key_cstr = StringValuePtr(key_str);
+  const char *key_cstr = to_charptr(key_str);
   data = sfcc_value_to_cimdata(value);
   status = args->ft->addArg(args, key_cstr, &data.value, data.type);
 
@@ -226,42 +259,40 @@ static int hash_to_cimargs_iterator(VALUE key, VALUE value, VALUE extra)
     return ST_CONTINUE;
   }
 
-  sfcc_rb_raise_if_error(status, "Can't add argument '%s'", StringValuePtr(key));
+  sfcc_rb_raise_if_error(status, "Can't add argument '%s'", to_charptr(key));
   return ST_STOP;
 }
 
-CMPIArgs *sfcc_hash_to_cimargs(VALUE hash)
+CIMCArgs *sfcc_hash_to_cimargs(VALUE hash)
 {
-  CMPIArgs *args;
-  args = newCMPIArgs(NULL);
+  CIMCArgs *args;
+  args = cimcEnv->ft->newArgs(cimcEnv, NULL);
   rb_hash_foreach(hash, hash_to_cimargs_iterator, (VALUE)args);
   return args;
 }
 
-VALUE sfcc_cimargs_to_hash(CMPIArgs *args)
+VALUE sfcc_cimargs_to_hash(CIMCArgs *args)
 {
-  CMPIArgs *ptr = NULL;
   int i = 0;
   int n = 0;
   VALUE hash;
-  CMPIString *argname;
-  CMPIData argdata;
-  CMPIStatus status;
+  CIMCString *argname;
+  CIMCData argdata;
+  CIMCStatus status;
   char *argname_cstr = NULL;
 
-  //Data_Get_Struct(args, CMPIArgs, ptr);
-  ptr = args;
-  if (!ptr) {
+  /* Data_Get_Struct(value, CIMCArgs, args); */
+  if (!args) {
     rb_raise(rb_eRuntimeError, "Can't retrieve args pointer");
     return Qnil;
   }
-  n = ptr->ft->getArgCount(ptr, NULL);
+  n = args->ft->getArgCount(args, 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 ) {
+    argdata = args->ft->getArgAt(args, i, &argname, &status);
+    if (!status.rc && argdata.state == CIMC_goodValue ) {
       argname_cstr = argname->ft->getCharPtr(argname, &status);
       if (!argname_cstr) {
         rb_raise(rb_eRuntimeError, "Can't retrieve argument name");
@@ -284,37 +315,37 @@ VALUE sfcc_cimargs_to_hash(CMPIArgs *args)
   return hash;
 }
 
-CMPIData sfcc_value_to_cimdata(VALUE value)
+CIMCData sfcc_value_to_cimdata(VALUE value)
 {
-  CMPIData data;
-  memset(&data, 0, sizeof(CMPIData));
-  data.state = CMPI_goodValue;
-  data.type = CMPI_null;
+  CIMCData data;
+  memset(&data, 0, sizeof(CIMCData));
+  data.state = CIMC_goodValue;
+  data.type = CIMC_null;
 
   switch (TYPE(value))
   {
   case T_NIL:
-    data.type = CMPI_null;
-    data.state = CMPI_nullValue;
+    data.type = CIMC_null;
+    data.state = CIMC_nullValue;
     break;
   case T_STRING:
-    data.type = CMPI_string;
-    data.value.string = newCMPIString(StringValuePtr(value), NULL);
+    data.type = CIMC_string;
+    data.value.string = cimcEnv->ft->newString(cimcEnv, to_charptr(value), NULL);
     break;
   case T_TRUE:
-    data.type = CMPI_boolean;
+    data.type = CIMC_boolean;
     data.value.boolean = 1;
     break;
   case T_FALSE:
-    data.type = CMPI_boolean;
+    data.type = CIMC_boolean;
     data.value.boolean = 0;
     break;
   case T_FIXNUM:
-    data.type = CMPI_sint64;
+    data.type = CIMC_sint64;
     data.value.Long = NUM2INT(value);
     break;
 /* not yet supported
-  case T_BIGNUM:       
+  case T_BIGNUM:
     break;
   case T_FLOAT:
     break;
@@ -327,17 +358,44 @@ CMPIData sfcc_value_to_cimdata(VALUE value)
   case T_DATA:
   default:
     if (CLASS_OF(value) == cSfccCimString) {
-      Data_Get_Struct(value, CMPIString, data.value.string);  
-      data.type = CMPI_string;
+      Data_Get_Struct(value, CIMCString, data.value.string);
+      data.type = CIMC_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);
+      VALUE cname;
+      const char *class_name;
+      data.state = CIMC_badValue;
+      data.type = CIMC_null;
+      cname = rb_funcall(rb_funcall(value, rb_intern("class"), 0), rb_intern("to_s"), 0);
+      class_name = to_charptr(cname);
       rb_raise(rb_eTypeError, "unsupported data data type: %s", class_name);
       return data;
     }
   }
   return data;
 }
+
+/*
+ * target_charptr
+ * Convert target type to const char *
+ */
+
+const char *
+to_charptr(VALUE v)
+{
+  const char *str;
+  if (SYMBOL_P(v)) {
+    str = rb_id2name(SYM2ID(v));
+  }
+  else if (TYPE(v) == T_STRING) {
+    str = StringValuePtr(v);
+  }
+  else if (v == Qnil) {
+    str = NULL;
+  }
+  else {
+    VALUE v_s = rb_funcall(v, rb_intern("to_s"), 0 );
+    str = StringValuePtr(v_s);
+  }
+  return str;
+}