cmpi-bindings 0.5.2 → 0.9.0

data/ext/src/cmpi_provider.c

@@ -46,10 +46,12 @@
 /* Needed for kill() */
 #include <signal.h>
 
+static int cmpi_bindings_trace_level = 0; /* increase by setenv CMPI_BINDINGS_TRACE_LEVEL */
+
 /* A simple stderr logging/tracing facility. */
 #ifndef _SBLIM_TRACE
-#define _SBLIM_TRACE(tracelevel,args) _logstderr args 
-void _logstderr(char *fmt,...)
+#define _SBLIM_TRACE(tracelevel,args) if (tracelevel <= cmpi_bindings_trace_level) { _logstderr args; }
+static void _logstderr(char *fmt,...)
 {
    va_list ap;
    va_start(ap,fmt);
@@ -142,20 +144,23 @@ proplist2target(const char** cplist)
 static char *
 fmtstr(const char* fmt, ...)
 {
+    static char buf[1];
     va_list ap; 
     int len; 
     char* str;
 
     va_start(ap, fmt); 
-    len = vsnprintf(NULL, 0, fmt, ap); 
+    len = vsnprintf(buf, 1, fmt, ap); /* vsnprintf(NULL, 0, ...) should work. bnc#762684 */
     va_end(ap); 
     if (len <= 0)
     {
+        fprintf(stderr, "*Err: vsnprintf(%s) = %d\n", fmt, len);
         return NULL; 
     }
     str = (char*)malloc(len+1); 
     if (str == NULL)
     {
+        fprintf(stderr, "*Err: malloc(%d) failed\n", len+1);
         return NULL; 
     }
     va_start(ap, fmt); 
@@ -868,6 +873,28 @@ references(
     return status;
 }
 
+
+#if defined(SWIGRUBY)
+/*
+ * Check type of VALUE
+ *
+ * return 0 if ok
+ * return -1 if bad type, set status accordingly
+ *
+ */
+
+static int
+check_ruby_type( VALUE value, int type, const char *message, CMPIStatus *status, ProviderMIHandle* hdl )
+{
+  if (TYPE(value) != type) {
+    status->rc = CMPI_RC_ERR_TYPE_MISMATCH;
+    status->msg = CMNewString(hdl->broker, message, NULL);
+    return -1;
+  }
+  return 0;
+}
+#endif
+
 /*
  * invokeMethod
  */
@@ -891,55 +918,72 @@ invokeMethod(
     TARGET_THREAD_BEGIN_BLOCK; 
     _ctx = SWIG_NewPointerObj((void*) ctx, SWIGTYPE_p__CMPIContext, 0);
     _objName = SWIG_NewPointerObj((void*) objName, SWIGTYPE_p__CMPIObjectPath, 0);
+  
+    /* Ruby style method invocation */
 #if defined(SWIGRUBY)
+  
+    /* de-camelize method name, might need 2time length */
     char *methodname = alloca(strlen(method) * 2 + 1);
     decamelize(method, methodname);
+  
+    /* access method arguments information via <decamelized>_args */
     int argsnamesize = strlen(methodname) + 5 + 1;
     char *argsname = alloca(argsnamesize); /* "<name>_args" */
     snprintf(argsname, argsnamesize, "%s_args", methodname);
+  
     /* get the args array, gives names of input and output arguments */
     VALUE args = rb_funcall(((ProviderMIHandle*)self->hdl)->implementation, rb_intern(argsname), 0);
-    Check_Type(args, T_ARRAY);
+    if (check_ruby_type(args, T_ARRAY, "invoke: <method>_args must be Array",  &status, (ProviderMIHandle*)self->hdl ) < 0)
+      return status;
+  
     VALUE argsin = rb_ary_entry(args, 0); /* array of input arg names */
-    Check_Type(argsin, T_ARRAY);
+    if (check_ruby_type(argsin, T_ARRAY, "invoke: Input arguments must be Array", &status, (ProviderMIHandle*)self->hdl ) < 0)
+      return status;
+
     int number_of_arguments = RARRAY_LEN(argsin) / 2;
+    _SBLIM_TRACE(1,("%s -> %d input args", argsname, number_of_arguments));
     /* 3 args will be added by TargetCall, 2 args are added here, others are input args to function */
     VALUE *input = alloca((3 + 2 + number_of_arguments) * sizeof(VALUE));
     input[3] = _ctx;
     input[4] = _objName;
     /* loop over input arg names and types and get CMPIData via CMGetArg() */
     int i;
-    for (i = 0; i < number_of_arguments; i += 2) {
+    for (i = 0; i < number_of_arguments; ++i) {
       const char *argname;
       CMPIData data;
-      argname = target_charptr(rb_ary_entry(argsin, i));
+      argname = target_charptr(rb_ary_entry(argsin, i*2));
       data = CMGetArg(in, argname, &status);
       if (status.rc != CMPI_RC_OK) {
 	if ((data.state & CMPI_nullValue)
 	    ||(data.state & CMPI_notFound)) {
-	  input[5+(i>>1)] = Target_Null;
+	  input[5+i] = Target_Null;
 	  continue;
 	} 
 	_SBLIM_TRACE(1,("Failed (rc %d) to get input arg %d:%s for %s", status.rc, i>>1, argname, method));
 	return status;
       }
-      input[5+(i>>1)] = data_value(&data);
+      input[5+i] = data_value(&data);
     }
+
+    /* actual provider call, passes output args and return value via 'result' */
     VALUE result = TargetCall((ProviderMIHandle*)self->hdl, &status, methodname, -(2+number_of_arguments), input);
+
     /* argsout is array of [<return_type>, <output_arg_name>, <output_arg_type>, ... */
     VALUE argsout = rb_ary_entry(args, 1);
     CMPIValue value;
     CMPIType expected_type;
     CMPIType actual_type;
-    Check_Type(argsout, T_ARRAY);
-    number_of_arguments = (RARRAY_LEN(argsout) - 1) / 2;
+    if (check_ruby_type(argsout, T_ARRAY, "invoke: Output arguments must be Array", &status, (ProviderMIHandle*)self->hdl) < 0)
+      return status;
+    number_of_arguments = (RARRAY_LEN(argsout) - 1);
 
     if (number_of_arguments > 0) {
       /* if output args are defined, result must be an array
        * result[0] is the return value
        * result[1..n] are the output args in argsout order
        */
-      Check_Type(result, T_ARRAY);
+      if (check_ruby_type(result, T_ARRAY, "invoke: function with output arguments must return Array", &status, (ProviderMIHandle*)self->hdl) < 0)
+        return status;
 
       /* loop over output arg names and types and set CMPIData via CMSetArg() */
       for (i = 0; i < number_of_arguments; i += 2) {
@@ -1260,7 +1304,13 @@ static CMPIInstanceMIFT InstanceMIFT__={
 static int
 createInit(ProviderMIHandle* miHdl, CMPIStatus* st)
 {
-    _SBLIM_TRACE(1,("\n>>>>> createInit() called, broker %p, miname= %s (ctx=%p), status %p\n", miHdl->broker, miHdl->miName, miHdl->context, st));
+    const char *trace_level = getenv("CMPI_BINDINGS_TRACE_LEVEL");
+    _SBLIM_TRACE(0,("\n>>>>> createInit() called, broker %p, miname= %s (ctx=%p), status %p, trace_level %s\n", miHdl->broker, miHdl->miName, miHdl->context, st, trace_level?trace_level:"(null)"));
+
+    if (trace_level) {
+      cmpi_bindings_trace_level = *trace_level - '0';
+      _SBLIM_TRACE(0,("tracing at level %d\n", cmpi_bindings_trace_level));
+    }
     return TargetInitialize(miHdl, st);
 }
 

data/ext/src/target_ruby.c

@@ -117,7 +117,7 @@ load_provider(VALUE arg)
   char *filename = alloca(strlen(classname) * 2 + 1);
   decamelize(classname, filename);
   ruby_script(filename);
-  _SBLIM_TRACE(1,("Ruby: loading (%s)", filename));
+  _SBLIM_TRACE(1,("<%d> Ruby: loading (%s)", getpid(), filename));
   req = rb_require(filename);
   /* Qtrue == just loaded, Qfalse = already loaded, else: fail */
   if ((req != Qtrue) && (req != Qfalse)) {
@@ -126,12 +126,12 @@ load_provider(VALUE arg)
   }
   /* Get Cmpi::Provider */
   VALUE val = rb_const_get(rb_cObject, rb_intern(RB_MODULE_NAME));
-  if (val == Qnil) {
+  if (NIL_P(val)) {
     _SBLIM_TRACE(1,("<%d> No such module '%s'", getpid(), RB_MODULE_NAME));
     return val;
   }
   val = rb_const_get(val, rb_intern(classname));
-  if (val == Qnil) {
+  if (NIL_P(val)) {
     _SBLIM_TRACE(1,("<%d> No such class '%s::%s'", getpid(), RB_MODULE_NAME, classname));
   }
   return val;
@@ -161,19 +161,28 @@ call_mi(VALUE args)
 /*
  * get Ruby exception trace -> CMPIString
  * 
+ * returns NULL if called without exception
  */
 
 #define TB_ERROR(str) {tbstr = str; goto cleanup;}
 static CMPIString *
 get_exc_trace(const CMPIBroker* broker)
 {
-    VALUE exception = rb_gv_get("$!"); /* get last exception */
-    VALUE reason = rb_funcall(exception, rb_intern("to_s"), 0 );
-    VALUE trace = rb_gv_get("$@"); /* get last exception trace */
-    VALUE backtrace = rb_funcall(trace, rb_intern("join"), 1, rb_str_new("\n\t", 2));
-
-    char* tmp = fmtstr("%s\n\t%s", StringValuePtr(reason), StringValuePtr(backtrace)); 
-    return broker->eft->newString(broker, tmp, NULL); 
+  VALUE exception = rb_gv_get("$!"); /* get last exception */
+  VALUE reason = rb_funcall(exception, rb_intern("to_s"), 0 );
+  VALUE trace = rb_gv_get("$@"); /* get last exception trace */
+  VALUE backtrace;
+  char* tmp;
+  CMPIString *result;
+
+  if (NIL_P(exception)) {
+    return NULL;
+  }
+  backtrace = rb_funcall(trace, rb_intern("join"), 1, rb_str_new("\n\t", 2));
+  tmp = fmtstr("%s\n\t%s", StringValuePtr(reason), StringValuePtr(backtrace)); 
+  result = broker->eft->newString(broker, tmp, NULL); 
+  free(tmp);
+  return result;
 }
 
 
@@ -189,19 +198,13 @@ get_exc_trace(const CMPIBroker* broker)
 static int
 RbGlobalInitialize(const CMPIBroker* broker, CMPIStatus* st)
 {
-  int error = 0;
   char *loadpath;
   VALUE searchpath;
 
-  if (_TARGET_INIT) {
-    return error; 
-  }
-  _TARGET_INIT=1; /* safe, since mutex is locked */
-  
-  _SBLIM_TRACE(1,("<%d> Ruby: Loading", getpid()));
-  
+  _SBLIM_TRACE(1,("<%d> Ruby: RbGlobalInitialize, stack @ %p", getpid(), &searchpath));
   ruby_init();
   ruby_init_loadpath();
+
   extern void SWIG_init();
   SWIG_init();
 
@@ -214,16 +217,20 @@ RbGlobalInitialize(const CMPIBroker* broker, CMPIStatus* st)
   if (loadpath) {
     struct stat buf;
     if (stat(loadpath, &buf)) {
-      _SBLIM_TRACE(1,("<%d> Can't stat $RUBY_PROVIDERS_DIR '%s'", getpid(), loadpath)); 
+      _SBLIM_TRACE(1,("<%d> Can't stat $%s '%s'", getpid(), RUBY_PROVIDERS_DIR_ENV, loadpath)); 
       return -1;
     }
     if ((buf.st_mode & S_IFDIR) == 0) {
-      _SBLIM_TRACE(1,("<%d> Not a directory: $RUBY_PROVIDERS_DIR '%s'", getpid(), loadpath)); 
+      _SBLIM_TRACE(1,("<%d> Not a directory: $%s '%s'", getpid(), RUBY_PROVIDERS_DIR_ENV, loadpath)); 
       return -1;
     }
+    _SBLIM_TRACE(1,("<%d> Loading providers from: $%s '%s'", getpid(), RUBY_PROVIDERS_DIR_ENV, loadpath)); 
     rb_ary_push(searchpath, rb_str_new2(loadpath));
   }
-  return error; 
+  else {
+    _SBLIM_TRACE(0, ("<%d> Hmm, %s not set ?!", getpid(), RUBY_PROVIDERS_DIR_ENV)); 
+  }
+  return 0;
 }
 
 
@@ -238,8 +245,9 @@ RbGlobalInitialize(const CMPIBroker* broker, CMPIStatus* st)
 static int
 TargetInitialize(ProviderMIHandle* hdl, CMPIStatus* st)
 {
-  VALUE args[6];
-  int error;
+  VALUE args[6] = { Qnil };
+  VALUE gc = Qnil;
+  int error = 0;
   int have_lock = 0;
 
   /* Set _CMPI_INIT, protected by _CMPI_INIT_MUTEX
@@ -249,7 +257,22 @@ TargetInitialize(ProviderMIHandle* hdl, CMPIStatus* st)
     perror("Can't lock _CMPI_INIT_MUTEX");
     abort();
   }
-  error = RbGlobalInitialize(hdl->broker, st);
+  if (_TARGET_INIT == 0) {
+    _TARGET_INIT = 1; /* safe, since mutex is locked */
+    error = RbGlobalInitialize(hdl->broker, st);
+  }
+#if 0
+  else {
+    /* Enforce GC.disable in provider upcalls; Ruby 1.9 crashes without */
+    gc = rb_const_get(rb_cObject, rb_intern("GC"));
+    if (NIL_P(gc)) {
+      _SBLIM_TRACE(0,("<%d> No such module 'GC'", getpid()));
+    }
+    else {
+      rb_funcall(gc, rb_intern("disable"), 0 );
+    }
+  }
+#endif
   pthread_mutex_unlock(&_CMPI_INIT_MUTEX);
   if (error != 0) {
     if (st != NULL) {
@@ -259,10 +282,11 @@ TargetInitialize(ProviderMIHandle* hdl, CMPIStatus* st)
     goto fail;
   }
 
-  _SBLIM_TRACE(1,("<%d> TargetInitialize(Ruby) called, miName '%s'", getpid(), hdl->miName));
+  _SBLIM_TRACE(1,("<%d> TargetInitialize(Ruby) called, miName '%s', stack @ %p, pthread %p", getpid(), hdl->miName, &have_lock, pthread_self()));
 
   if (pthread_mutex_trylock(&_stack_init_mutex) == 0) {
     have_lock = 1;
+    _SBLIM_TRACE(1,("<%d> RUBY_INIT_STACK for pthread %p", getpid(), pthread_self()));
     RUBY_INIT_STACK
   }
 
@@ -271,6 +295,7 @@ TargetInitialize(ProviderMIHandle* hdl, CMPIStatus* st)
    */
   args[0] = rb_protect(load_provider, (VALUE)hdl->miName, &error);
   if (error) {
+    _SBLIM_TRACE(1,("Ruby: load_provider(%s) failed !", hdl->miName));
     if (st != NULL) {
       st->rc = CMPI_RC_ERR_INVALID_CLASS;
       st->msg = CMNewString(hdl->broker, "Failed to load provider", NULL);
@@ -284,11 +309,13 @@ TargetInitialize(ProviderMIHandle* hdl, CMPIStatus* st)
   args[4] = SWIG_NewPointerObj((void*) hdl->broker, SWIGTYPE_p__CMPIBroker, 0);
   args[5] = SWIG_NewPointerObj((void*) hdl->context, SWIGTYPE_p__CMPIContext, 0);
   hdl->implementation = rb_protect(call_mi, (VALUE)args, &error);
+  if (error) {
+    _SBLIM_TRACE(1,("Ruby: %s.new() failed !", hdl->miName));
+  }
 
 fail:
   if (error) {
     CMPIString *trace = get_exc_trace(hdl->broker);
-    _SBLIM_TRACE(1,("Ruby: FAILED creating %s: %s", hdl->miName, CMGetCharPtr(trace)));
     if (st != NULL) {
       st->rc = CMPI_RC_ERR_INVALID_CLASS;
       st->msg = trace;
@@ -302,7 +329,10 @@ fail:
   }
   if (have_lock)
     pthread_mutex_unlock(&_stack_init_mutex);
-  _SBLIM_TRACE(1,("Initialize() %s", (error == 0)?"succeeded":"failed"));
+  if (!NIL_P(gc)) {
+    rb_funcall(gc, rb_intern("enable"), 0 );
+  }
+  _SBLIM_TRACE(1,("TargetInitialize() %s", (error == 0)?"succeeded":"failed"));
   return error;
 }
 
@@ -311,6 +341,15 @@ fail:
  * TargetCall
  * 
  * Call function 'opname' with nargs arguments within managed interface hdl->implementation
+ * 
+ * If nargs < 0: 'invoke method' call to provider
+ *               nargs is followed by a VALUE* array of -nargs+3 elements
+ *               [0] = undef
+ *               [1] = undef
+ *               [2] = undef
+ *               [3] = _ctx;
+ *               [4] = _objName;
+ *               [5...] = function arguments
  */
 
 static Target_Type
@@ -322,12 +361,17 @@ TargetCall(ProviderMIHandle* hdl, CMPIStatus* st,
   int i;
   VALUE *args, result, op = rb_intern(opname);
   va_list vargs; 
+  _SBLIM_TRACE(5,("TargetCall([hdl %p]%s:%d args, pthread %p)", hdl, opname, nargs, pthread_self()));
 
   if (pthread_mutex_trylock(&_stack_init_mutex) == 0) {
     have_lock = 1;
+#if (RUBY_API_VERSION_MAJOR > 1) || (RUBY_API_VERSION_MAJOR == 1 && RUBY_API_VERSION_MINOR < 9)
+    _SBLIM_TRACE(1,("<%d> RUBY_INIT_STACK", getpid()));
     RUBY_INIT_STACK
+#endif
   }
   if (invoke) {
+    /* invoke style: get pre-allocated array of arguments */
     va_start(vargs, nargs);
     args = va_arg(vargs, VALUE *);
     va_end(vargs);
@@ -345,17 +389,15 @@ TargetCall(ProviderMIHandle* hdl, CMPIStatus* st,
   args[0] = (VALUE)(hdl->implementation);
   args[1] = op;
   args[2] = (VALUE)(nargs-3);
-  if (!invoke && (nargs > 3))
-    {
-      va_start(vargs, nargs);
-      for (i = 3; i < nargs; ++i)
-	{
-	  VALUE value;
-	  value = va_arg(vargs, VALUE);
-	  args[i] = (value == (VALUE)NULL) ? Qnil : value;
-	}
-      va_end(vargs);
+  if (!invoke && (nargs > 3)) {
+    va_start(vargs, nargs);
+    for (i = 3; i < nargs; ++i) {
+      VALUE value;
+      value = va_arg(vargs, VALUE);
+      args[i] = (value == (VALUE)NULL) ? Qnil : value;
     }
+    va_end(vargs);
+  }
 
   /* call the Ruby function
    * possible results:
@@ -366,51 +408,59 @@ TargetCall(ProviderMIHandle* hdl, CMPIStatus* st,
    */
   result = rb_protect(call_mi, (VALUE)args, &i);
 
-  if (i) /* exception ? */
-    {
-      CMPIString *trace = get_exc_trace(hdl->broker);
-      char* str = fmtstr("Ruby: calling '%s' failed: %s", opname, CMGetCharPtr(trace)); 
-      _SBLIM_TRACE(1,("%s", str));
-      st->rc = CMPI_RC_ERR_FAILED; 
-      st->msg = hdl->broker->eft->newString(hdl->broker, str, NULL); 
-      goto done;
+  if (i) { /* exception ? */
+    CMPIString *trace = get_exc_trace(hdl->broker);
+    char *trace_s;
+    char* str;
+    if (trace) {
+      trace_s = CMGetCharPtr(trace);
     }
-  if (NIL_P(result)) /* not or wrongly implemented */
-    {
-      st->rc = CMPI_RC_ERR_NOT_SUPPORTED;
-      goto done;
+    else {
+      trace_s = "Unknown reason";
     }
+    str = fmtstr("Ruby: calling '%s' failed: %s", opname, trace_s); 
+    if (trace)
+      trace->ft->release(trace);
+    _SBLIM_TRACE(1,("%s", str));
+    st->rc = CMPI_RC_ERR_FAILED; 
+    st->msg = hdl->broker->eft->newString(hdl->broker, str, NULL); 
+    free(str);
+    goto done;
+  }
+  if (NIL_P(result)) { /* not or wrongly implemented */
+    st->rc = CMPI_RC_ERR_NOT_SUPPORTED;
+    goto done;
+  }
 
   if (invoke) {
     st->rc = CMPI_RC_OK;
     goto done;
   }
 
-  if (result != Qtrue)
-    {
-      VALUE resulta = rb_check_array_type(result);
-      VALUE rc, msg;
-      if (NIL_P(resulta))
-	{
-	  char* str = fmtstr("Ruby: calling '%s' returned unknown result", opname); 
-	  st->rc = CMPI_RC_ERR_FAILED;
-	  st->msg = hdl->broker->eft->newString(hdl->broker, str, NULL); 
-	  goto done;
-	}
-  
-      rc = rb_ary_entry(resulta, 0);
-      msg = rb_ary_entry(resulta, 1);
-      if (!FIXNUM_P(rc))
-	{
-	  char* str = fmtstr("Ruby: calling '%s' returned non-numeric rc code", opname); 
-	  st->rc = CMPI_RC_ERR_FAILED;
-	  st->msg = hdl->broker->eft->newString(hdl->broker, str, NULL); 
-	  goto done;
-	}
-      st->rc = FIX2LONG(rc);
-      st->msg = hdl->broker->eft->newString(hdl->broker, StringValuePtr(msg), NULL);
+  if (result != Qtrue) {
+    VALUE resulta = rb_check_array_type(result);
+    VALUE rc, msg;
+    if (NIL_P(resulta)) {
+      char* str = fmtstr("Ruby: calling '%s' returned unknown result", opname); 
+      st->rc = CMPI_RC_ERR_FAILED;
+      st->msg = hdl->broker->eft->newString(hdl->broker, str, NULL); 
+      free(str);
+      goto done;
+    }
+
+    rc = rb_ary_entry(resulta, 0);
+    msg = rb_ary_entry(resulta, 1);
+    if (!FIXNUM_P(rc)){
+      char* str = fmtstr("Ruby: calling '%s' returned non-numeric rc code", opname); 
+      st->rc = CMPI_RC_ERR_FAILED;
+      st->msg = hdl->broker->eft->newString(hdl->broker, str, NULL); 
+      free(str);
       goto done;
     }
+    st->rc = FIX2LONG(rc);
+    st->msg = hdl->broker->eft->newString(hdl->broker, StringValuePtr(msg), NULL);
+    goto done;
+  }
   
   /* all is fine */
   st->rc = CMPI_RC_OK;
@@ -428,7 +478,7 @@ done:
 static void
 TargetCleanup(ProviderMIHandle * hdl)
 {
-  _SBLIM_TRACE(1,("TargetCleanup(hdl %p)", hdl));
+  _SBLIM_TRACE(1,("Ruby: TargetCleanup(hdl %p)", hdl));
   /* free() provider instance */
   if (hdl && hdl->implementation) {
     _SBLIM_TRACE(1,("unregister(%p)", hdl->implementation));
@@ -454,7 +504,7 @@ TargetCleanup(ProviderMIHandle * hdl)
   {
     _SBLIM_TRACE(1,("Calling ruby_finalize()"));
     ruby_finalize();
-    _TARGET_INIT=0; // false
+    _TARGET_INIT = 0; // false
   }
   pthread_mutex_unlock(&_CMPI_INIT_MUTEX);
   return;

data/lib/cmpi/provider.rb

@@ -50,6 +50,9 @@ public
     # call-seq:
     #   ProviderIF.new broker
     #
+    # Attn: This is different from the derived provider
+    #       which gets name, broker, context passed to initialize
+    #
     def initialize broker
       Cmpi::broker = broker
     end

data/lib/cmpi.rb

@@ -179,6 +179,83 @@ module Cmpi
     CMPI_ARRAY | self.charsptrA
   end
 
+  #
+  # 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
+  # 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
+    else
+      raise "Invalid CIM DateTime '#{str}'"
+    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
   #
   # Base class for ValueMap/Values classes from genprovider
   #
@@ -247,7 +324,8 @@ module Cmpi
 	# -> 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}"
+#	STDERR.printf "Instance.#{n} = #{v}[#{v.class}]:#{t}" % [n, v, v.class, t]
+     	STDERR.printf "Instance.%s = %s[%s]:%04x\n" % [n, v, v.class, t]
         self[n,v] = t
       else
 #	STDERR.puts "CMPIInstance.#{name} -> #{self[s].inspect}"