openwsman 2.4.1 → 2.4.12.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 05d9166f187b741d314e0dcef1425925cad610e7
+  data.tar.gz: 3b9dac7671f734ecc1f11596b0d8edf124b622a2
+SHA512:
+  metadata.gz: 56aea7009ab94074582ff95c7666e3d9fead0a5b2c4ace7062e075fec7ab34f8f0029817349a5e6f3b8bbe8eb6779a71e2e053afe66104394c968a334d838c9c
+  data.tar.gz: ab60cc7cb66e9721c7c2d8463465084f9fb423fc6aebe775bc5e71bdb3e416cfa370a56ed154d50b1b21a0c7225f9d618553773112977ffb4748dbbefa6aaf92

data/ext/openwsman/extconf.rb

@@ -28,6 +28,12 @@ unless have_library('xml2', 'xmlNewDoc')
 end
 find_header 'libxml/parser.h', '/usr/include/libxml2'
 
+swig = find_executable("swig")
+raise "SWIG not found" unless swig
+
+major, minor, path = RUBY_VERSION.split(".")
+raise "SWIG failed to run" unless system("#{swig} -ruby -autorename -DRUBY_VERSION=#{major}#{minor} -I. -I/usr/include/openwsman -o openwsman_wrap.c openwsman.i")
+
 $CPPFLAGS = "-I/usr/include/openwsman -I.."
 
 create_makefile('_openwsman')

data/ext/openwsman/openwsman.i

@@ -0,0 +1,595 @@
+%{
+/*
+ * type definitions to keep the C code generic
+ */
+ 
+#if defined(SWIGPYTHON)
+#define Target_Null_p(x) (x == Py_None)
+#define Target_INCREF(x) Py_INCREF(x)
+#define Target_DECREF(x) Py_DECREF(x)
+#define Target_True Py_True
+#define Target_False Py_False
+#define Target_Null Py_None
+#define Target_Type PyObject*
+#define Target_Bool(x) PyBool_FromLong(x)
+#define Target_Char16(x) PyInt_FromLong(x)
+#define Target_Int(x) PyInt_FromLong(x)
+#define Target_String(x) PyString_FromString(x)
+#define Target_Real(x) Py_None
+#define Target_Array() PyList_New(0)
+#define Target_SizedArray(len) PyList_New(len)
+#define Target_ListSet(x,n,y) PyList_SetItem(x,n,y)
+#define Target_Append(x,y) PyList_Append(x,y)
+#include <Python.h>
+#define TARGET_THREAD_BEGIN_BLOCK SWIG_PYTHON_THREAD_BEGIN_BLOCK
+#define TARGET_THREAD_END_BLOCK SWIG_PYTHON_THREAD_END_BLOCK
+#define TARGET_THREAD_BEGIN_ALLOW SWIG_PYTHON_THREAD_BEGIN_ALLOW
+#define TARGET_THREAD_END_ALLOW SWIG_PYTHON_THREAD_END_ALLOW
+#endif
+
+#if defined(SWIGRUBY)
+#define Target_Null_p(x) NIL_P(x)
+#define Target_INCREF(x) 
+#define Target_DECREF(x) 
+#define Target_True Qtrue
+#define Target_False Qfalse
+#define Target_Null Qnil
+#define Target_Type VALUE
+#define Target_Bool(x) ((x)?Qtrue:Qfalse)
+#define Target_Char16(x) INT2FIX(x)
+#define Target_Int(x) INT2FIX(x)
+#define Target_String(x) rb_str_new2(x)
+#define Target_Real(x) rb_float_new(x)
+#define Target_Array() rb_ary_new()
+#define Target_SizedArray(len) rb_ary_new2(len)
+#define Target_ListSet(x,n,y) rb_ary_store(x,n,y)
+#define Target_Append(x,y) rb_ary_push(x,y)
+#define TARGET_THREAD_BEGIN_BLOCK do {} while(0)
+#define TARGET_THREAD_END_BLOCK do {} while(0)
+#define TARGET_THREAD_BEGIN_ALLOW do {} while(0)
+#define TARGET_THREAD_END_ALLOW do {} while(0)
+#include <ruby.h>
+#if HAVE_RUBY_IO_H
+#include <ruby/io.h> /* Ruby 1.9 style */
+#else
+#include <rubyio.h>
+#endif
+#if HAVE_RUBY_VERSION_H
+#include <ruby/version.h>
+#endif
+#endif
+
+#if defined(SWIGPERL)
+#define TARGET_THREAD_BEGIN_BLOCK do {} while(0)
+#define TARGET_THREAD_END_BLOCK do {} while(0)
+#define TARGET_THREAD_BEGIN_ALLOW do {} while(0)
+#define TARGET_THREAD_END_ALLOW do {} while(0)
+
+SWIGINTERNINLINE SV *SWIG_From_long  SWIG_PERL_DECL_ARGS_1(long value);
+SWIGINTERNINLINE SV *SWIG_FromCharPtr(const char *cptr);
+SWIGINTERNINLINE SV *SWIG_From_double  SWIG_PERL_DECL_ARGS_1(double value);
+
+#define Target_Null_p(x) (x == NULL)
+#define Target_INCREF(x) 
+#define Target_DECREF(x) 
+#define Target_True (&PL_sv_yes)
+#define Target_False (&PL_sv_no)
+#define Target_Null NULL
+#define Target_Type SV *
+#define Target_Bool(x) (x)?Target_True:Target_False
+#define Target_Char16(x) SWIG_From_long(x)
+#define Target_Int(x) SWIG_From_long(x)
+#define Target_String(x) SWIG_FromCharPtr(x)
+#define Target_Real(x) SWIG_From_double(x)
+#define Target_Array() (SV *)newAV()
+#define Target_SizedArray(len) (SV *)newAV()
+#define Target_ListSet(x,n,y) av_store((AV *)(x),n,y)
+#define Target_Append(x,y) av_push(((AV *)(x)), y)
+#include <perl.h>
+#include <EXTERN.h>
+#endif
+
+%}
+
+#if defined(SWIGRUBY)
+%module Openwsman
+
+%{
+#include <ruby.h>
+#if HAVE_RUBY_IO_H
+#include <ruby/io.h> /* Ruby 1.9 style */
+#else
+#include <rubyio.h>
+#endif
+
+#if HAVE_RUBY_THREAD_H /* New threading model */
+#include <ruby/thread.h>
+#endif
+%}
+
+%typemap(in) FILE* {
+#if RUBY_VERSION > 18
+  struct rb_io_t *fptr;
+#else
+  struct OpenFile *fptr;
+#endif
+  Check_Type($input, T_FILE);
+  GetOpenFile($input, fptr);
+  /*rb_io_check_writable(fptr);*/
+#if RUBY_VERSION > 18
+  $1 = rb_io_stdio_file(fptr);
+#else
+  $1 = GetReadFile(fptr);
+#endif
+}
+
+#endif /* SWIGRUBY */
+
+#if defined(SWIGJAVA)
+%module OpenWSMan
+
+/* evaluate constants */
+%javaconst(1);
+
+/* extend JNI class to automatically load shared library from jar file */
+%pragma(java) jniclassimports=%{
+	 import java.io.File;
+	 import java.io.InputStream;
+	 import java.io.FileOutputStream;
+%}
+%pragma(java) jniclasscode=%{
+	public final static String libraryFileName = "libjwsman.so";
+
+	static {
+		InputStream inputStream = OpenWSManJNI.class.getClassLoader()
+				.getResourceAsStream(libraryFileName);
+
+		try {
+			File libraryFile = File.createTempFile(libraryFileName, null);
+			libraryFile.deleteOnExit();
+
+			FileOutputStream fileOutputStream = new FileOutputStream(libraryFile);
+			byte[] buffer = new byte[8192];
+			int bytesRead;
+			while ((bytesRead = inputStream.read(buffer)) > 0) {
+				fileOutputStream.write(buffer, 0, bytesRead);
+			}
+			fileOutputStream.close();
+			inputStream.close();
+
+			try {
+				System.load(libraryFile.getPath());
+			} catch (UnsatisfiedLinkError e) {
+				System.err.println("Arch: " + System.getProperty("os.arch"));
+				System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n"	+ e);
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+%}
+
+/* get the java environment so we can throw exceptions */
+%{
+    static JNIEnv *jenv;
+    /*:nodoc:*/
+    jint JNI_OnLoad(JavaVM *vm, void *reserved) {
+      (*vm)->AttachCurrentThread(vm, (void **)&jenv, NULL);
+      return JNI_VERSION_1_2;
+    }
+%}
+#endif /* SWIGJAVA */
+
+#if defined(SWIGPYTHON)
+%module pywsman
+#endif
+
+#if defined(SWIGPERL)
+%module openwsman
+
+//==================================
+// Typemap: Allow FILE* as PerlIO
+//----------------------------------
+%typemap(in) FILE* {
+    $1 = PerlIO_findFILE(IoIFP(sv_2io($input)));
+}
+#endif /* SWIGPERL */
+
+%{
+#if defined(SWIGPERL)
+/* filter_t is defined in Perls CORE/perl.h */
+#define filter_t filter_type
+
+/* undef Perl's die and warn macros as libu is going to reuse this names */
+#undef die
+#undef warn
+#endif /* SWIGPERL */
+
+#include <u/libu.h>
+#include <wsman-types.h>
+#include <wsman-client.h>
+#include <wsman-client-transport.h>
+#include <wsman-api.h>
+#include <wsman-xml-binding.h>
+#include <wsman-xml.h>
+#include <wsman-epr.h>
+#include <wsman-filter.h>
+#include <wsman-soap.h>
+#include <wsman-soap-envelope.h>
+#include <openwsman.h>
+
+#if defined(SWIGRUBY)
+#include <ruby/helpers.h>
+
+SWIGEXPORT
+/* Init_ for the %module, defined by Swig
+ * :nodoc:
+ */
+void Init_Openwsman(void);
+
+SWIGEXPORT
+/* Init_ for the .so lib, called by Ruby
+ * :nodoc:
+ */
+void Init__openwsman(void) {
+  Init_Openwsman();
+}
+#endif
+#if defined(SWIGPYTHON)
+#include <python/helpers.h>
+#endif
+#if defined(SWIGJAVA)
+#include <java/helpers.h>
+#endif
+#if defined(SWIGPERL)
+#include <perl/helpers.h>
+#endif
+
+/* Provide WsManTransport definition so it can be used as
+ * dedicated datatype in bindings.
+ * :nodoc:ly, its aliased to WsManClient
+ *
+ */
+struct _WsManTransport { };
+typedef struct _WsManTransport WsManTransport;
+
+static void set_debug(int dbg);
+
+/*
+ * Set openwsman debug level.
+ * call-seq:
+ *   Openwsman::debug = -1 # full debug
+ *
+ */
+static void set_debug(int dbg) {
+  static int init = 0;
+
+  if (!init && dbg != 0) {
+    init = 1;
+    debug_add_handler( debug_message_handler, DEBUG_LEVEL_ALWAYS, NULL );
+  }
+  wsman_debug_set_level( dbg );
+	
+}
+
+/* module-level methods */
+
+static int get_debug(void);
+
+/*
+ * Return openwsman debug level.
+ * call-seq:
+ *   Openwsman::debug -> Integer
+ *
+ */
+static int get_debug(void) {
+  return (int)wsman_debug_get_level();
+}
+
+static WsXmlDocH create_soap_envelope(void);
+
+/*
+ * Create empty SOAP envelope
+ * call-seq:
+ *   Openwsman::create_soap_envelope -> XmlDoc
+ *
+ */
+static WsXmlDocH create_soap_envelope() {
+  return ws_xml_create_soap_envelope();
+}
+
+static WsXmlDocH create_doc_from_file(const char *filename, const char *encoding);
+
+/*
+ * Read XmlDoc from file
+ * call-seq:
+ *   Openwsman::create_doc_from_file("/path/to/file", "utf-8") -> XmlDoc
+ *
+ */
+static WsXmlDocH create_doc_from_file(const char *filename, const char *encoding) {
+  return xml_parser_file_to_doc( filename, encoding, 0);                 
+}
+
+static WsXmlDocH create_doc_from_string(const char *buf, const char *encoding);
+
+/*
+ * Read XmlDoc from string
+ * call-seq:
+ *   Openwsman::create_doc_from_string("<xml ...>", "utf-8") -> XmlDoc
+ *
+ */
+static WsXmlDocH create_doc_from_string(const char *buf, const char *encoding) {
+  return xml_parser_memory_to_doc( buf, strlen(buf), encoding, 0);
+}
+
+static char *uri_classname(const char *uri);
+/*
+ * get classname from resource URI
+ * call-seq:
+ *   Openwsman::uri_classname("http://sblim.sf.net/wbem/wscim/1/cim-schema/2/Linux_OperatingSystem") -> "Linux_OperatingSystem"
+ *
+ */
+static char *uri_classname(const char *uri) {
+  const char *lastslash = strrchr(uri,'/');
+  if (lastslash) {
+    return strdup(lastslash+1);
+  }
+  return NULL;
+}
+
+static const char *uri_prefix(const char *classname);
+/*
+ * Map classname (class schema) to resource uri prefix
+ * call-seq:
+ *   Openwsman::uri_prefix("Linux") -> "http://sblim.sf.net/wbem/wscim/1/cim-schema/2"
+ *   Openwsman::uri_prefix("Win32") -> "http://schemas.microsoft.com/wbem/wsman/1/wmi"
+ *
+ */
+static const char *uri_prefix(const char *classname) {
+  static struct map {
+    int len;
+    const char *schema;
+    const char *prefix;
+  } mapping[] = {
+    /* dmtf CIM */
+    { 3, "CIM", "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2" },
+    /* dmtf reserved */
+    { 3, "PRS", "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2" },
+    /* Microsoft WMI */
+    { 5, "Win32", "http://schemas.microsoft.com/wbem/wsman/1/wmi" },
+    /* openwbem.org */
+    { 8, "OpenWBEM", "http://schema.openwbem.org/wbem/wscim/1/cim-schema/2" },
+    /* sblim */
+    { 5, "Linux", "http://sblim.sf.net/wbem/wscim/1/cim-schema/2" },
+    /* omc-project */
+    { 3, "OMC", "http://schema.omc-project.org/wbem/wscim/1/cim-schema/2" },
+    /* pegasus.org */
+    { 2, "PG", "http://schema.openpegasus.org/wbem/wscim/1/cim-schema/2" },
+    /* Intel AMT */
+    { 3, "AMT", "http://intel.com/wbem/wscim/1/amt-schema/1" },
+    /* Intel */
+    { 3, "IPS", "http://intel.com/wbem/wscim/1/ips-schema/1" },
+    /* Sun */
+    { 3, "Sun","http://schemas.sun.com/wbem/wscim/1/cim-schema/2" },
+    /* Microsoft HyperV */
+    { 4, "Msvm", "http://schemas.microsoft.com/wbem/wsman/1/wmi" },
+    /* Dell DRAC */
+    { 4, "DCIM", "http://schemas.dell.com/wbem/wscim/1/cim-schema/2" },
+    /* Unisys */
+    { 4, "SPAR", "http://schema.unisys.com/wbem/wscim/1/cim-schema/2" },
+    /* Fujitsu */
+    { 3, "SVS", "http://schemas.ts.fujitsu.com/wbem/wscim/1/cim-schema/2" },
+    { 0, NULL, NULL }
+  };
+  const char *schema_end;
+  struct map *map;
+  int len;
+  if (classname == NULL)
+    return NULL;
+  if (strcmp(classname, "*") == 0) {
+    return "http://schemas.dmtf.org/wbem/wscim/1";
+  }
+  if ((strcmp(classname, "meta_class") == 0)
+      ||(strncmp(classname, "__", 2) == 0)) {
+    return "http://schemas.microsoft.com/wbem/wsman/1/wmi";
+  }
+  schema_end = strchr(classname, '_');
+  if (schema_end == NULL)
+    return NULL; /* Bad class name */
+  len = schema_end - classname;
+  map = mapping;
+  while (map->len > 0) {
+    if ((len == map->len)
+        && (strncasecmp(classname, map->schema, map->len) == 0)) {
+      return map->prefix;
+    }
+    ++map;
+  }
+  return NULL;
+}
+
+#if defined(SWIGRUBY)
+static epr_t *my_epr_deserialize(WsXmlNodeH node);
+/*:nodoc:*/
+static epr_t *my_epr_deserialize(WsXmlNodeH node) {
+  if (strcmp(WSA_EPR, ws_xml_get_node_local_name(node)) == 0) {
+    /* Use node as-is if its already a WSA_EPR */
+    return epr_deserialize(node, NULL, NULL, 1);
+  }
+  /* else search the WSA_EPR node */
+  return epr_deserialize(node, XML_NS_ADDRESSING, WSA_EPR, 1);
+}
+#endif
+
+static char *epr_prefix(const char *uri);
+/* Get prefix from a EPR uri
+ * :nodoc:
+ */
+static char *epr_prefix(const char *uri) {
+  char *classname = uri_classname(uri);
+  const char *prefix = uri_prefix(classname);
+  if (prefix) {
+    const char *lastslash;
+    if (strncmp(uri, prefix, strlen(prefix)) == 0) {
+      return strdup(prefix);
+    }
+    lastslash = strrchr(uri, '/');
+    if (lastslash) {
+      return strndup(uri, lastslash-uri);
+    }
+  }
+  return strdup(uri);
+}
+
+%}
+
+#if RUBY_VERSION > 18
+%{
+  typedef struct {
+    WsManClient *client;
+    client_opt_t *options;
+    filter_t *filter;
+    const char *resource_uri;
+    epr_t *epr;
+    const char *context;
+    const char *identifier;
+    const char *data;
+    size_t size;
+    const char *encoding;
+    const char *method;
+    WsXmlDocH method_args;
+  } wsmc_action_args_t;
+
+  WsXmlDocH
+  ruby_enumerate_thread(wsmc_action_args_t *args) {
+    return wsmc_action_enumerate(args->client, args->resource_uri, args->options, args->filter);
+  }
+  WsXmlDocH
+  ruby_identify_thread(wsmc_action_args_t *args) {
+    return wsmc_action_identify(args->client, args->options);
+  }
+  WsXmlDocH
+  ruby_get_from_epr_thread(wsmc_action_args_t *args) {
+    return wsmc_action_get_from_epr(args->client, args->epr, args->options);
+  }
+  WsXmlDocH
+  ruby_delete_from_epr_thread(wsmc_action_args_t *args) {
+    return wsmc_action_delete_from_epr(args->client, args->epr, args->options);
+  }
+  WsXmlDocH
+  ruby_pull_thread(wsmc_action_args_t *args) {
+    return wsmc_action_pull(args->client, args->resource_uri, args->options, args->filter, args->context);
+  }
+  WsXmlDocH
+  ruby_create_fromtext_thread(wsmc_action_args_t *args) {
+    return wsmc_action_create_fromtext(args->client, args->resource_uri, args->options, args->data, args->size, args->encoding);
+  }
+  WsXmlDocH
+  ruby_put_fromtext_thread(wsmc_action_args_t *args) {
+    return wsmc_action_put_fromtext(args->client, args->resource_uri, args->options, args->data, args->size, args->encoding);
+  }
+  WsXmlDocH
+  ruby_release_thread(wsmc_action_args_t *args) {
+    return wsmc_action_release(args->client, args->resource_uri, args->options, args->context);
+  }
+  WsXmlDocH
+  ruby_get_thread(wsmc_action_args_t *args) {
+    return wsmc_action_get(args->client, args->resource_uri, args->options);
+  }
+  WsXmlDocH
+  ruby_delete_thread(wsmc_action_args_t *args) {
+    return wsmc_action_delete(args->client, args->resource_uri, args->options);
+  }
+  WsXmlDocH
+  ruby_invoke_thread(wsmc_action_args_t *args) { 
+    return wsmc_action_invoke(args->client, args->resource_uri, args->options, args->method, args->method_args);
+  }
+  WsXmlDocH
+  ruby_subscribe_thread(wsmc_action_args_t *args) {
+    return wsmc_action_subscribe(args->client, args->resource_uri, args->options, args->filter);
+  }
+  WsXmlDocH
+  ruby_unsubscribe_thread(wsmc_action_args_t *args) {
+    return wsmc_action_unsubscribe(args->client, args->resource_uri, args->options, args->identifier);
+  }
+  WsXmlDocH
+  ruby_renew_thread(wsmc_action_args_t *args) {
+    return wsmc_action_renew(args->client, args->resource_uri, args->options, args->identifier);
+  }
+%}
+#endif
+
+
+/*
+ * hash_t typemaps
+ */
+#if defined(SWIGJAVA)
+%typemap(jni) hash_t * "jobject"
+%typemap(jtype) hash_t * "java.util.Map"
+%typemap(jstype) hash_t * "java.util.Map"
+%typemap(javaout) hash_t * {
+	return $jnicall;
+ }
+#endif
+%typemap(out) hash_t * {
+#if defined(SWIGJAVA)
+ $result = hash2value(jenv, $1);
+#else
+ $result = hash2value($1);
+#endif
+}
+
+%typemap(in) hash_t * {
+ $input = value2hash(NULL, $1, 0);
+}
+
+%ignore __undefined;
+
+%include exception.i
+
+#if defined(SWIGJAVA)
+
+/* if java, pass the new exception macro to C not just SWIG */
+#undef SWIG_exception
+#define SWIG_exception(code, msg) {SWIG_JavaException(jenv, code, msg); goto fail;}
+%inline %{
+#undef SWIG_exception
+#define SWIG_exception(code, msg) {SWIG_JavaException(jenv, code, msg); goto fail;}
+%}
+
+#endif
+
+%include "version.i"
+
+/* start with wsman-xml to get the __WsXmlFoo -> XmlFoo renames right */
+%include "wsman-xml.i"
+
+%include "wsman-names.i"
+
+%include "wsman-epr.i"
+
+%include "wsman-filter.i"
+
+%include "wsman-soap.i"
+
+%include "wsman-transport.i"
+
+%include "wsman-client_opt.i"
+
+%include "wsman-client.i"
+
+/*-----------------------------------------------------------------*/
+/* debug */
+
+#if defined(SWIGRUBY)
+  %rename("debug=") set_debug(int debug);
+#endif
+static void set_debug(int dbg);
+#if defined(SWIGRUBY)
+  %rename("debug") get_debug();
+#endif
+static int get_debug();
+static WsXmlDocH create_soap_envelope();
+static WsXmlDocH create_doc_from_file(const char *filename, const char *encoding = "UTF-8");
+static WsXmlDocH create_doc_from_string(const char *buf, const char *encoding = "UTF-8");
+static const char *uri_prefix(const char* classname);