cmpi-bindings 0.9.5 → 0.9.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f1cefd23941e2b4ebbda38e5661bd8ce55966373
-  data.tar.gz: cde95d6241639d9ad75a69d72b7a5c6975c9d6f1
+  metadata.gz: 107a02c0b033ad9845df5c4b8a1d4053d270f87c
+  data.tar.gz: c88d671fd2a43e905af5891e3b62f42b6e161840
 SHA512:
-  metadata.gz: 068cf7f60cee5715603d9d5d2c22e935ecbe7851c619465eceb557ce3bda3fa31e6f9a188ae1d2f78993e6898155cd80f1bc5d48ab08fffe61c380c1b9c1673c
-  data.tar.gz: a92c3337d9244c123f8ffff18b502fe6b1fb6ece0893966d89d8542d4ad4fd862abe3dab42ccd556765b0ec5553254db351ee5c642de6b560acbc700f9af8039
+  metadata.gz: 45538fbf49c3ca8b9c36a28f89d2bdc07415223340fa0e942a81e14a9314bd9bf94872f0baee792c71a2f899fa6a926cefcab9abc4a8e7c03bb70ed6d7ab798a
+  data.tar.gz: 624d9b9c47ea84ce82f90c09b070ccecaa70ffe755f30e398649700b479022f0cab146417c017f278f8fe3acc9808af939ae71c32466597217863aa8f1e2846c

data/ext/src/cmpi_provider.c

@@ -874,27 +874,6 @@ references(
 }
 
 
-#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
  */
@@ -919,93 +898,8 @@ invokeMethod(
     _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);
-    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 */
-    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) {
-      const char *argname;
-      CMPIData data;
-      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] = 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] = 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;
-    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
-       */
-      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) {
-	const char *argname;
-	argname = target_charptr(rb_ary_entry(argsout, i+1));
-	expected_type = FIX2ULONG(rb_ary_entry(argsout, i+2));
-	actual_type = target_to_value(rb_ary_entry(result, (i >> 1) + 1), &value, expected_type);
-	status = CMAddArg(out, argname, &value, actual_type);
-	if (status.rc != CMPI_RC_OK) {
-	  _SBLIM_TRACE(1,("Failed (rc %d) to set output arg %d:%s for %s; expected type %x, actual type %x", status.rc, i>>1, argname, method, expected_type, actual_type));
-	  return status;
-	}
-      }
-      /* result[0] is the return value */
-      result = rb_ary_entry(result, 0);
-
-    }
-    expected_type = FIX2ULONG(rb_ary_entry(argsout, 0));
-    actual_type = target_to_value(result, &value, expected_type);
-    CMReturnData(rslt, &value, actual_type);
-    CMReturnDone(rslt);
-  
+    TargetInvoke((ProviderMIHandle*)self->hdl, _ctx, rslt, _objName, method, in, out, &status);
 #else
     Target_Type _rslt;
     Target_Type _in;

data/ext/src/target_ruby.c

@@ -515,3 +515,188 @@ TargetCleanup(ProviderMIHandle * hdl)
   return;
 }
 
+
+/*
+ * Check type of VALUE
+ * - used by invokeMethod -
+ *
+ * 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;
+}
+
+
+/*
+ * protected_target_to_value
+ * call target_to_value via rb_protect in order to catch exceptions
+ *
+ */
+
+static VALUE
+call_ttv(VALUE args)
+{
+  VALUE *values = (VALUE *)args;
+  return target_to_value((Target_Type)values[0], (CMPIValue *)values[1], (CMPIType)values[2]);
+}
+
+static VALUE
+protected_target_to_value(ProviderMIHandle *hdl, Target_Type data, CMPIValue *value, CMPIType type, CMPIStatus *status)
+{
+  int error = 0;
+  VALUE args[3];
+  VALUE result;
+  args[0] = (VALUE)data;
+  args[1] = (VALUE)value;
+  args[2] = (VALUE)type;
+  result = rb_protect(call_ttv, (VALUE)args, &error);
+
+  if (error) {
+    CMPIString *trace = get_exc_trace(hdl->broker);
+    char *trace_s;
+    char* str;
+    if (trace) {
+      trace_s = CMGetCharPtr(trace);
+    }
+    else {
+      trace_s = "Unknown reason";
+    }
+    str = fmtstr("Ruby: %s", trace_s); 
+    if (trace)
+      trace->ft->release(trace);
+    _SBLIM_TRACE(1,("%s", str));
+    status->rc = CMPI_RC_ERR_FAILED; 
+    status->msg = hdl->broker->eft->newString(hdl->broker, str, NULL); 
+    free(str);
+  }
+  else {
+    status->rc = CMPI_RC_OK;
+  }
+  return result;
+}
+
+/*
+ * TargetInvoke
+ * Ruby style method invocation
+ */
+static void
+TargetInvoke(
+        ProviderMIHandle* hdl,
+        Target_Type _ctx,
+        const CMPIResult* rslt,
+        Target_Type _objName,
+        const char* method,
+        const CMPIArgs* in,
+        CMPIArgs* out,
+        CMPIStatus *status)
+{
+  /* 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(hdl->implementation, rb_intern(argsname), 0);
+  if (check_ruby_type(args, T_ARRAY, "invoke: <method>_args must be Array",  status, hdl ) < 0) {
+    return;
+  }
+  
+  VALUE argsin = rb_ary_entry(args, 0); /* array of input arg names */
+  if (check_ruby_type(argsin, T_ARRAY, "invoke: Input arguments of <method>_args must be Array", status, hdl ) < 0) {
+    return;
+  }
+
+  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) {
+    const char *argname;
+    CMPIData data;
+    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] = Target_Null;
+        continue;
+      } 
+      _SBLIM_TRACE(1,("Failed (rc %d) to get input arg %d:%s for %s", status->rc, i>>1, argname, method));
+      return;
+    }
+    input[5+i] = data_value(&data);
+  }
+
+  /* actual provider call, passes output args and return value via 'result' */
+  VALUE result = TargetCall(hdl, status, methodname, -(2+number_of_arguments), input);
+
+  /* check CMPIStatus */
+  if (status->rc != CMPI_RC_OK) {
+    return;
+  }
+
+  /* argsout (from <method>_args) 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;
+  if (check_ruby_type(argsout, T_ARRAY, "invoke: Output arguments of <method>_args must be Array", status, hdl) < 0) {
+    return;
+  }
+  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
+     */
+    if (check_ruby_type(result, T_ARRAY, "invoke: function with output arguments must return Array", status, hdl) < 0) {
+      return;
+    }
+    /* loop over output arg names and types and set CMPIData via CMSetArg() */
+    for (i = 0; i < number_of_arguments; i += 2) {
+      const char *argname;
+      argname = target_charptr(rb_ary_entry(argsout, i+1));
+      expected_type = FIX2ULONG(rb_ary_entry(argsout, i+2));
+      actual_type = protected_target_to_value(hdl, rb_ary_entry(result, (i >> 1) + 1), &value, expected_type, status);
+      if (status->rc != CMPI_RC_OK) {
+        _SBLIM_TRACE(0,("Failed (rc %d) type conversion for output arg %d:%s in call to %s; expected type %x, actual type %x", status->rc, i>>1, argname, method, expected_type, actual_type));
+        return;
+      }
+      *status = CMAddArg(out, argname, &value, actual_type);
+      if (status->rc != CMPI_RC_OK) {
+        _SBLIM_TRACE(1,("Failed (rc %d) to set output arg %d:%s for %s; expected type %x, actual type %x", status->rc, i>>1, argname, method, expected_type, actual_type));
+        return;
+      }
+    }
+    /* result[0] is the return value */
+    result = rb_ary_entry(result, 0);
+    
+  }
+  expected_type = FIX2ULONG(rb_ary_entry(argsout, 0));
+  actual_type = protected_target_to_value(hdl, result, &value, expected_type, status);
+  if (status->rc != CMPI_RC_OK) {
+    _SBLIM_TRACE(0,("Failed (rc %d) type conversion for return value of %s; expected type %x, actual type %x", status->rc, method, expected_type, actual_type));
+    return;
+  }
+  CMReturnData(rslt, &value, actual_type);
+  CMReturnDone(rslt);
+}

metadata

@@ -1,55 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: cmpi-bindings
 version: !ruby/object:Gem::Version
-  version: 0.9.5
+  version: 0.9.9
 platform: ruby
 authors:
 - Klaus Kämpf
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-26 00:00:00.000000000 Z
+date: 2014-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.9'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.5'
 description: The cmpi-bindings gem provides a Ruby API to write CIM providers
@@ -60,13 +60,13 @@ extensions:
 - ext/cmpi-bindings/extconf.rb
 extra_rdoc_files: []
 files:
-- lib/cmpi.rb
-- lib/cmpi/provider.rb
-- ext/cmpi-bindings/string_array.h
 - ext/cmpi-bindings/cmpi_wrap.c
+- ext/cmpi-bindings/extconf.rb
+- ext/cmpi-bindings/string_array.h
 - ext/src/cmpi_provider.c
 - ext/src/target_ruby.c
-- ext/cmpi-bindings/extconf.rb
+- lib/cmpi.rb
+- lib/cmpi/provider.rb
 homepage: http://www.github.com/kkaempf/cmpi-bindings
 licenses: []
 metadata: {}
@@ -77,17 +77,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: Write CIM providers in Ruby