sfcc 0.1.0

data/CHANGELOG.rdoc

@@ -0,0 +1,4 @@
+
+== 0.1.0
+
+* First public version

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+
+Copyright (c) 2009 Novell Inc.
+ 
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+ 
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/Manifest.txt

@@ -0,0 +1,28 @@
+CHANGELOG.rdoc
+MIT-LICENSE
+Manifest.txt
+README.rdoc
+Rakefile
+TODO.rdoc
+ext/sfcc/cim_class.c
+ext/sfcc/cim_class.h
+ext/sfcc/cim_client.c
+ext/sfcc/cim_client.h
+ext/sfcc/cim_enumeration.c
+ext/sfcc/cim_enumeration.h
+ext/sfcc/cim_instance.c
+ext/sfcc/cim_instance.h
+ext/sfcc/cim_object_path.c
+ext/sfcc/cim_object_path.h
+ext/sfcc/cim_string.c
+ext/sfcc/cim_string.h
+ext/sfcc/extconf.rb
+ext/sfcc/sfcc.c
+ext/sfcc/sfcc.h
+lib/sfcc.rb
+test/helper.rb
+test/test_sfcc.rb
+test/test_sfcc_cim_class.rb
+test/test_sfcc_cim_client.rb
+test/test_sfcc_cim_instance.rb
+test/test_sfcc_cim_object_path.rb

data/README.rdoc

@@ -0,0 +1,60 @@
+
+= ruby-sfcc
+
+* http://github.com/dmacvicar/ruby-sfcc
+
+== INTRODUCTION
+
+ruby-sfcc provides the SBLIM client API ( http://sblim.wiki.sourceforge.net/Sfcc ) for ruby.
+
+You can use it to connect to any CIMOM talking CIM-XML, but it can take advantage of
+sfcb CIMOM by connecting using a native interface.
+
+== Quick Start
+
+You can create a gem by running rake gem.
+
+See the testsuite for more examples. Or run rake docs.
+
+    require 'sfcc'
+
+    client = Sfcc::Cim::Client.connect('http://root@localhost:5988')
+    op = Sfcc::Cim::ObjectPath.new("root/cimv2", "")
+    result = client.query(op, "select * from CIM_OperatingSystem", "wql")
+    result.each do |instance|
+      puts "query result: #{instance}"
+    end
+
+== FAQ
+
+* Why not using SWIG?
+
+  sfcc has a complex API based on function tables to simulate an object
+  oriented environment in C which would make wrapping it complicated.
+
+* Why the API?
+
+  The motivation is to have the plain API available, and use it to access
+  the CIMOM, gaining the footprint of SBLIM plus features like the
+  local interface to talk with the CIMOM without overhead.
+
+  So the API is pretty "raw", and it is supposed to be consumed by
+ActiveCim ( http://github.com/dmacvicar/activecim ) which is a more
+ruby-like API to do CIM based management.
+
+* How to run the testsuite?
+
+  You need a CIMOM with base providers (ie: Linux_OperatingSystem) running
+  on localhost 5988 with no authentication
+
+== Known Issues
+
+* If you call Instance#references without a filter class you may get an
+  error. It seems sfcb can't load a provider.
+
+* ObjectPath qualifier methods crash
+
+== Authors
+
+* Duncan Mac-Vicar P. <dmacvicar@suse.de>
+

data/Rakefile

@@ -0,0 +1,32 @@
+$: << File.join(File.dirname(__FILE__), "test")
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+
+task :default => [:compile, :docs, :test]
+
+Hoe.plugin :yard
+
+HOE = Hoe.spec 'sfcc' do
+  developer('Duncan Mac-Vicar P.', 'dmacvicar@suse.de')
+  self.summary = "WBEM client for ruby based on the sblim-sfcc library"
+  self.description = "ruby-sfcc allows to access a CIMOM either with the WBEM protocol or by using the SfcbLocal interface provided by the sblim-sfcb CIMOM implementation from the sblim project."
+  self.readme_file = ['README', ENV['HLANG'], 'rdoc'].compact.join('.')
+  self.history_file = ['CHANGELOG', ENV['HLANG'], 'rdoc'].compact.join('.')
+  self.extra_rdoc_files = FileList['*.rdoc']
+  self.clean_globs = [
+    'lib/sfcc/*.{o,so,bundle,a,log,dll}',
+  ]
+ 
+  %w{ rake-compiler }.each do |dep|
+    self.extra_dev_deps << [dep, '>= 0']
+  end
+  self.extra_deps << ['shoulda', '>= 0']
+  self.extra_deps << ['yard', '>= 0']
+  self.spec_extras = { :extensions => ["ext/sfcc/extconf.rb"] }
+end
+
+
+gem 'rake-compiler', '>= 0.4.1'
+require 'rake/extensiontask'
+Rake::ExtensionTask.new('sfcc')

data/TODO.rdoc

@@ -0,0 +1,28 @@
+
+== General:
+
+* add convencience [] operator to Class and Instance to set and
+  retrieve properties
+
+== Missing relevant APIs
+
+Other APIs may be missing, but they may not be relevant in a ruby
+style API.
+
+=== CIMCClass
+
+Only available in the v2 API (we use v1):
+
+* getSuperClassName
+* getKeyList
+* toString
+* relocate
+* getCharClassName
+* getCharSuperClassName
+* isAssociation
+* isAbstract
+* isIndication
+* getPropQualAt
+
+
+

data/ext/sfcc/cim_class.c

@@ -0,0 +1,274 @@
+
+#include "cim_class.h"
+
+static void
+dealloc(CMPIConstClass *cimclass)
+{
+  SFCC_DEC_REFCOUNT(cimclass);
+}
+
+/**
+ * call-seq:
+ *   name()
+ *
+ * gets the class name
+ */
+static VALUE class_name(VALUE self)
+{
+  CMPIConstClass *cimclass = NULL;
+  CMPIString *classname;
+  Data_Get_Struct(self, CMPIConstClass, cimclass);
+  classname = cimclass->ft->getClassName(cimclass, NULL);
+  return rb_str_new2(classname->ft->getCharPtr(classname, NULL));
+}
+
+/**
+ * call-seq:
+ *   property(name)
+ *
+ * gets a named property value
+ */
+static VALUE property(VALUE self, VALUE name)
+{
+  CMPIConstClass *ptr = NULL;
+  CMPIStatus status;
+  CMPIData data;
+  memset(&status, 0, sizeof(CMPIStatus));
+  Data_Get_Struct(self, CMPIConstClass, ptr);
+  data = ptr->ft->getProperty(ptr, StringValuePtr(name), &status);
+  if ( !status.rc )
+    return sfcc_cimdata_to_value(data);
+
+  sfcc_rb_raise_if_error(status, "Can't retrieve property '%s'", StringValuePtr(name));
+  return Qnil;
+}
+
+/**
+ * call-seq:
+ *   cimclass.each_property do |name, value|
+ *      ...
+ *   end
+ *
+ * enumerates properties yielding the property name and
+ * its value
+ *
+ */
+static VALUE each_property(VALUE self)
+{
+  CMPIConstClass *ptr = NULL;
+  CMPIStatus status;
+  int k=0;
+  int num_props=0;
+  CMPIString *property_name = NULL;
+  CMPIData data;
+  Data_Get_Struct(self, CMPIConstClass, ptr);
+
+  num_props = ptr->ft->getPropertyCount(ptr, &status);
+  if (!status.rc) {
+    for (; k < num_props; ++k) {
+      data = ptr->ft->getPropertyAt(ptr, k, &property_name, &status);
+      if (!status.rc) {
+        rb_yield_values(2, (property_name ? rb_str_intern(rb_str_new2(property_name->ft->getCharPtr(property_name, NULL))) : Qnil), sfcc_cimdata_to_value(data));
+      }
+      else {
+        sfcc_rb_raise_if_error(status, "Can't retrieve property #%d", k);
+      } 
+      if (property_name) CMRelease(property_name);
+    }
+  }
+  else {
+    sfcc_rb_raise_if_error(status, "Can't retrieve property count");
+  }
+  return Qnil;
+}
+
+/**
+ * call-seq:
+ *   property_count()
+ *
+ * Gets the number of properties contained in this class
+ */
+static VALUE property_count(VALUE self)
+{
+  CMPIConstClass *ptr = NULL;
+  Data_Get_Struct(self, CMPIConstClass, ptr);
+  return UINT2NUM(ptr->ft->getPropertyCount(ptr, NULL));
+}
+
+/**
+ * call-seq:
+ *   qualifier(name)
+ *
+ * gets a named qualifier value
+ */
+static VALUE qualifier(VALUE self, VALUE name)
+{
+  CMPIConstClass *ptr = NULL;
+  CMPIStatus status;
+  CMPIData data;
+  memset(&status, 0, sizeof(CMPIStatus));
+  Data_Get_Struct(self, CMPIConstClass, ptr);
+  data = ptr->ft->getQualifier(ptr, StringValuePtr(name), &status);
+  if ( !status.rc )
+    return sfcc_cimdata_to_value(data);
+
+  sfcc_rb_raise_if_error(status, "Can't retrieve qualifier '%s'", StringValuePtr(name));
+  return Qnil;
+}
+
+/**
+ * call-seq:
+ *   cimclass.each_qualifier do |name, value|
+ *      ...
+ *   end
+ *
+ * enumerates properties yielding the qualifier name and
+ * its value
+ *
+ */
+static VALUE each_qualifier(VALUE self)
+{
+  CMPIConstClass *ptr = NULL;
+  CMPIStatus status;
+  int k=0;
+  int num_props=0;
+  CMPIString *qualifier_name = NULL;
+  CMPIData data;
+  Data_Get_Struct(self, CMPIConstClass, ptr);
+
+  num_props = ptr->ft->getQualifierCount(ptr, &status);
+  if (!status.rc) {
+    for (; k < num_props; ++k) {
+      data = ptr->ft->getQualifierAt(ptr, k, &qualifier_name, &status);
+      if (!status.rc) {
+        rb_yield_values(2, (qualifier_name ? rb_str_intern(rb_str_new2(qualifier_name->ft->getCharPtr(qualifier_name, NULL))) : Qnil), sfcc_cimdata_to_value(data));
+      }
+      else {
+        sfcc_rb_raise_if_error(status, "Can't retrieve qualifier #%d", k);
+      } 
+      if (qualifier_name) CMRelease(qualifier_name);
+    }
+  }
+  else {
+    sfcc_rb_raise_if_error(status, "Can't retrieve qualifier count");
+  }
+  return Qnil;
+}
+
+/**
+ * call-seq:
+ *   qualifier_count()
+ *
+ * Gets the number of qualifiers in this class
+ */
+static VALUE qualifier_count(VALUE self)
+{
+  CMPIConstClass *ptr = NULL;
+  Data_Get_Struct(self, CMPIConstClass, ptr);
+  return UINT2NUM(ptr->ft->getQualifierCount(ptr, NULL));
+}
+
+/**
+ * call-seq:
+ *   property_qualifier(property_name, qualifier_name)
+ *
+ * gets a named property qualifier value
+ */
+static VALUE property_qualifier(VALUE self, VALUE property_name, VALUE qualifier_name)
+{
+  CMPIConstClass *ptr = NULL;
+  CMPIStatus status;
+  CMPIData data;
+  memset(&status, 0, sizeof(CMPIStatus));
+  Data_Get_Struct(self, CMPIConstClass, ptr);
+  data = ptr->ft->getPropertyQualifier(ptr, StringValuePtr(property_name),
+                                        StringValuePtr(qualifier_name), &status);
+  if ( !status.rc )
+    return sfcc_cimdata_to_value(data);
+
+  sfcc_rb_raise_if_error(status, "Can't retrieve property_qualifier '%s'", StringValuePtr(qualifier_name));
+  return Qnil;
+}
+
+/**
+ * call-seq:
+ *   cimclass.each_property_qualifier(property_name) do |name, value|
+ *      ...
+ *   end
+ *
+ * enumerates properties yielding the property qualifier name and
+ * its value
+ *
+ */
+static VALUE each_property_qualifier(VALUE self, VALUE property_name)
+{
+  CMPIConstClass *ptr = NULL;
+  CMPIStatus status;
+  int k=0;
+  int num_props=0;
+  CMPIString *property_qualifier_name = NULL;
+  CMPIData data;
+  Data_Get_Struct(self, CMPIConstClass, ptr);
+
+  num_props = ptr->ft->getPropertyQualifierCount(ptr, StringValuePtr(property_name), &status);
+  if (!status.rc) {
+    for (; k < num_props; ++k) {
+      data = ptr->ft->getPropertyQualifierAt(ptr, StringValuePtr(property_name), k, &property_qualifier_name, &status);
+      if (!status.rc) {
+        rb_yield_values(2, (property_qualifier_name ? rb_str_intern(rb_str_new2(property_qualifier_name->ft->getCharPtr(property_qualifier_name, NULL))) : Qnil), sfcc_cimdata_to_value(data));
+      }
+      else {
+        sfcc_rb_raise_if_error(status, "Can't retrieve property qualifier #%d", k);
+      } 
+      if (property_qualifier_name) CMRelease(property_qualifier_name);
+    }
+  }
+  else {
+    sfcc_rb_raise_if_error(status, "Can't retrieve property qualifier count");
+  }
+  return Qnil;
+}
+
+/**
+ * call-seq:
+ *   property_qualifier_count(property_name)
+ *
+ * Gets the number of qualifiers contained in this property
+ */
+static VALUE property_qualifier_count(VALUE self, VALUE property_name)
+{
+  CMPIConstClass *ptr = NULL;
+  Data_Get_Struct(self, CMPIConstClass, ptr);
+  return UINT2NUM(ptr->ft->getPropertyQualifierCount(ptr, StringValuePtr(property_name), NULL));
+}
+
+VALUE
+Sfcc_wrap_cim_class(CMPIConstClass *cimclass)
+{
+  SFCC_INC_REFCOUNT(cimclass);
+  return Data_Wrap_Struct(cSfccCimClass, NULL, dealloc, cimclass);
+}
+
+VALUE cSfccCimClass;
+void init_cim_class()
+{
+  VALUE sfcc = rb_define_module("Sfcc");
+  VALUE cimc = rb_define_module_under(sfcc, "Cim");
+
+  /**
+   * class from the CIM schema
+   */
+  VALUE klass = rb_define_class_under(cimc, "Class", rb_cObject);
+  cSfccCimClass = klass;
+
+  rb_define_method(klass, "class_name", class_name, 0);
+  rb_define_method(klass, "property", property, 1);
+  rb_define_method(klass, "each_property", each_property, 0);
+  rb_define_method(klass, "property_count", property_count, 0);
+  rb_define_method(klass, "qualifier", qualifier, 1);
+  rb_define_method(klass, "each_qualifier", each_qualifier, 0);
+  rb_define_method(klass, "qualifier_count", qualifier_count, 0);
+  rb_define_method(klass, "property_qualifier", property_qualifier, 2);
+  rb_define_method(klass, "each_property_qualifier", each_property_qualifier, 1);
+  rb_define_method(klass, "property_qualifier_count", property_qualifier_count, 1);
+}

data/ext/sfcc/cim_class.h

@@ -0,0 +1,12 @@
+
+#ifndef RUBY_NATIVE_SFCC_CIM_CLASS_H
+#define RUBY_NATIVE_SFCC_CIM_CLASS_H
+
+#include "sfcc.h"
+
+void init_cim_class();
+
+extern VALUE cSfccCimClass;
+VALUE Sfcc_wrap_cim_class(CMPIConstClass *cimclass);
+
+#endif