ruby-libvirt 0.2.0 → 0.3.0

data/NEWS

@@ -1,3 +1,46 @@
+2010-12-12 0.3.0
+  * Implementation of Libvirt::open_auth, Libvirt::event_register_impl
+  * Updated Connect class, implementing conn.compare_cpu, conn.baseline_cpu,
+    conn.domain_event_register_any, conn.domain_event_deregister_any,
+    conn.domain_event_register, conn.domain_event_deregister, and
+    conn.create_domain_xml.
+  * Updated Domain class, implementing dom.get_vcpus, dom.update_device,
+    dom.scheduler_type, dom.scheduler_parameters, dom.scheduler_parameters=,
+    dom.num_vcpus, dom.vcpus_flags=, and dom.qemu_monitor_command.
+  * Updated Interface class, implementing interface.free
+  * Many potential memory leaks have been fixed.
+  * Many bugfixes.
+  * Documentation update of many methods, including all of the lookup methods
+    that were missing before.
+
+2010-11-10
+  * Gem for version 0.2.0 pushed to rubygems.org
+
+2010-07-01 0.2.0
+  * Updated Storage class, implementing pool.active?, pool.persistent?,
+    pool.vol_create_xml_from.
+  * Updated Connect class, implementing conn.node_free_memory,
+    conn.node_cells_free_memory, conn.node_get_security_model, conn.encrypted?,
+    conn.libversion, and conn.secure?
+  * Updated Network class, implementing network.active? and network.persistent?
+  * Update Domain class, implementing conn.domain_xml_from_native,
+    conn.domain_xml_to_native, dom.migrate_to_uri,
+    dom.migrate_set_max_downtime, dom.managed_save, dom.has_managed_save?,
+    dom.managed_save_remove, dom.security_label, dom.block_stats,
+    dom.memory_stats, dom.blockinfo, dom.block_peek, dom.memory_peek,
+    dom.active?, dom.persistent?, dom.snapshot_create_xml,
+    dom.num_of_snapshots, dom.list_snapshots, dom.lookup_snapshot_by_name,
+    dom.has_current_snapshot?, dom.revert_to_snapshot, dom.current_snapshot,
+    snapshot.xml_desc, snapshot.delete, dom.job_info, and dom.abort_job.
+  * Implementation of the NodeDevice class.
+  * Implementation of the Secret class.
+  * Implementation of the NWFilter class.
+  * Implementation of the Interface class.
+  * Conversion of the development tree to git.
+  * New maintainer (Chris Lalancette). David Lutterkort has agreed to transfer
+    maintainership since he is not actively involved in their development
+    anymore.
+
 2008-11-18 0.1.0
   * Add binding for virConnectFindStoragePoolSources (clalance)
   * Fix dom_migrate (clalance)

data/README

@@ -7,7 +7,7 @@ Usage
 -----
 
 In your ruby code, do a "require 'libvirt'"; to obtain a connection, use
-'Libvirt::open' or 'Libvirt::openReadOnly'. See tests/*.rb for more
+'Libvirt::open' or 'Libvirt::open_read_only'. See tests/*.rb for more
 examples.
 
 Hacking
@@ -23,4 +23,42 @@ To run against the checkout, make sure you set RUBYLIB (assuming DIR is the
 toplevel of your source checkout):
 
   export RUBYLIB=$dir/lib:$dir/ext/libvirt
-  ruby -rlibvirt -e 'puts Libvirt::version("xen")[0]'
+  ruby -rlibvirt -e 'puts Libvirt::version[0]'
+
+Notes
+-----
+As of December 12, 2010, the ruby-libvirt bindings support all of the libvirt
+APIs up to libvirt commit hash e8d05c978da774b7abbbc38dfcc00b9b582fdf72
+with the following exceptions:
+
+- virConnectRef
+- virDomainGetConnect
+- virDomainRef
+- virDomainSetMemoryParameters
+- virDomainGetMemoryParameters
+- virDomainIsUpdated
+- virDomainOpenConsole
+- virNetworkGetConnect
+- virNetworkRef
+- virInterfaceGetConnect
+- virInterfaceRef
+- virStoragePoolGetConnect
+- virStoragePoolRef
+- virStorageVolGetConnect
+- virStorageVolRef
+- virNodeDeviceRef
+- virSecretGetConnect
+- virSecretRef
+- virStreamNew
+- virStreamRef
+- virStreamSend
+- virStreamRecv
+- virStreamSendAll
+- virStreamRecvAll
+- virStreamEventAddCallback
+- virStreamEventUpdateCallback
+- virStreamEventRemoveCallback
+- virStreamFinish
+- virStreamAbort
+- virStreamFree
+- virNWFilterRef

data/README.rdoc

@@ -5,6 +5,8 @@ The module Libvirt provides bindings to libvirt[http://libvirt.org]
 The various *Ptr types in Libvirt map loosely to the following Ruby classes:
 
 [virConnectPtr] Libvirt::Connect
+[virNodeInfoPtr] Libvirt::Connect::Nodeinfo
+[virSecurityModelPtr] Libvirt::Connect::NodeSecurityModel
 [virDomainPtr]  Libvirt::Domain
 [virDomainInfoPtr]  Libvirt::Domain::Info
 [virDomainInterfaceStatsPtr] Libvirt::Domain::InterfaceInfo
@@ -13,6 +15,7 @@ The various *Ptr types in Libvirt map loosely to the following Ruby classes:
 [virDomainMemoryStatPtr] Libvirt::Domain::MemoryStats
 [virDomainBlockInfoPtr] Libvirt::Domain::BlockInfo
 [virDomainSnapshotPtr] Libvirt::Domain::Snapshot
+[virDomainJobInfoPtr] Libvirt::Domain::JobInfo
 [virNetworkPtr] Libvirt::Network
 [virNWFilterPtr] Libvirt::NWFilter
 [virNodeDevicePtr] Libvirt::NodeDevice
@@ -20,6 +23,5 @@ The various *Ptr types in Libvirt map loosely to the following Ruby classes:
 [virStoragePoolInfoPtr] Libvirt::StoragePoolInfo
 [virStorageVolPtr] Libvirt::StorageVol
 [virStorageVolInfoPtr] Libvirt::StorageVolInfo
-[virNodeInfoPtr] Libvirt::Nodeinfo
 [virSecretPtr] Libvirt::Secret
 [virInterfacePtr] Libvirt::Interface

data/Rakefile

@@ -15,7 +15,7 @@ require 'rake/testtask'
 require 'rake/gempackagetask'
 
 PKG_NAME='ruby-libvirt'
-PKG_VERSION='0.2.0'
+PKG_VERSION='0.3.0'
 
 EXT_CONF='ext/libvirt/extconf.rb'
 MAKEFILE="ext/libvirt/Makefile"
@@ -31,14 +31,12 @@ LIBVIRT_SRC << MAKEFILE
 CLEAN.include [ "ext/**/*.o", LIBVIRT_MODULE,
                 "ext/**/depend" ]
 
-CLOBBER.include [ "config.save", "ext/**/mkmf.log",
+CLOBBER.include [ "config.save", "ext/**/mkmf.log", "ext/**/extconf.h",
                   MAKEFILE ]
 
 #
 # Build locally
 #
-# FIXME: We can't get rid of install.rb yet, since there's no way
-# to pass config options to extconf.rb
 file MAKEFILE => EXT_CONF do |t|
     Dir::chdir(File::dirname(EXT_CONF)) do
          unless sh "ruby #{File::basename(EXT_CONF)}"
@@ -59,7 +57,7 @@ desc "Build the native library"
 task :build => LIBVIRT_MODULE
 
 Rake::TestTask.new(:test) do |t|
-    t.test_files = FileList['tests/tc_*.rb']
+    t.test_files = [ 'tests/test_conn.rb', 'tests/test_domain.rb', 'tests/test_interface.rb', 'tests/test_network.rb', 'tests/test_nodedevice.rb', 'tests/test_nwfilter.rb', 'tests/test_open.rb', 'tests/test_secret.rb', 'tests/test_storage.rb' ]
     t.libs = [ 'lib', 'ext/libvirt' ]
 end
 task :test => :build
@@ -107,14 +105,6 @@ Rake::GemPackageTask.new(SPEC) do |pkg|
     pkg.need_zip = true
 end
 
-desc "Update the ruby-libvirt site"
-task :site => [ :rdoc ] do |t|
-    system("rsync -av doc/site/ libvirt:/data/www/libvirt.org/ruby/")
-    if $? != 0
-        raise "rsync failed: #{$?}"
-    end
-end
-
 desc "Build (S)RPM for #{PKG_NAME}"
 task :rpm => [ :package ] do |t|
     system("sed -e 's/@VERSION@/#{PKG_VERSION}/' #{SPEC_FILE} > pkg/#{SPEC_FILE}")
@@ -126,15 +116,3 @@ task :rpm => [ :package ] do |t|
         end
     end
 end
-
-desc "Release a version to the site"
-task :dist => [ :rpm ] do |t|
-    puts "Copying files"
-    unless sh "scp -p #{DIST_FILES.to_s} libvirt:/data/www/libvirt.org/ruby/download"
-        $stderr.puts "Copy to libvirt failed"
-        break
-    end
-    puts "Commit and tag #{PKG_VERSION}"
-    system "hg commit -m 'Released version #{PKG_VERSION}'"
-    system "hg tag -m 'Tag release #{PKG_VERSION}' #{PKG_NAME}-#{PKG_VERSION}"
-end

data/ext/libvirt/_libvirt.c

@@ -38,22 +38,26 @@ static VALUE c_libvirt_version;
 
 VALUE m_libvirt;
 
-// define additional errors here
-static VALUE e_ConnectionError;         // ConnectionError - error durring connection establishment
+/* define additional errors here */
+static VALUE e_ConnectionError;         /* ConnectionError - error during connection establishment */
 VALUE e_DefinitionError;
 VALUE e_RetrieveError;
 VALUE e_Error;
+VALUE e_NoSupportError;
+
+/* custom error function to suppress libvirt printing to stderr */
+static void rubyLibvirtErrorFunc(void *userdata, virErrorPtr err){
+}
 
 /*
  * call-seq:
- *   Libvirt::version(type) -> [ libvirt_version, type_version ]
+ *   Libvirt::version(type=nil) -> [ libvirt_version, type_version ]
  *
  * Call
  * +virGetVersion+[http://www.libvirt.org/html/libvirt-libvirt.html#virGetVersion]
- * to get the version of libvirt and of the hypervisor TYPE. Returns an
- * array with two entries of type Libvirt::Version.
+ * to get the version of libvirt and of the hypervisor TYPE.
  */
-VALUE libvirt_version(int argc, VALUE *argv, VALUE m) {
+static VALUE libvirt_version(int argc, VALUE *argv, VALUE m) {
     unsigned long libVer;
     VALUE type;
     unsigned long typeVer;
@@ -63,8 +67,7 @@ VALUE libvirt_version(int argc, VALUE *argv, VALUE m) {
     rb_scan_args(argc, argv, "01", &type);
 
     r = virGetVersion(&libVer, get_string_or_nil(type), &typeVer);
-    _E(r < 0, create_error(rb_eArgError, "virGetVersion",
-                           "Failed to get version", NULL));
+    _E(r < 0, create_error(rb_eArgError, "virGetVersion", NULL));
 
     result = rb_ary_new2(2);
     rargv[0] = rb_str_new2("libvirt");
@@ -91,47 +94,625 @@ static VALUE internal_open(int argc, VALUE *argv, VALUE m, int readonly)
     else
         conn = virConnectOpen(uri_c);
 
-    if (conn == NULL)
-        rb_raise(e_ConnectionError, "Failed to open%sconnection to '%s'", readonly ? " readonly " : " ", uri_c);
+    _E(conn == NULL, create_error(e_ConnectionError,
+                                  readonly ? "virConnectOpenReadOnly" : "virConnectOpen",
+                                  NULL));
 
     return connect_new(conn);
 }
 
 /*
  * call-seq:
- *   Libvirt::open(url) -> Libvirt::Connect
+ *   Libvirt::open(uri=nil) -> Libvirt::Connect
  *
  * Call
  * +virConnectOpen+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectOpen]
- * to open a connection to a URL.  Returns a new Libvirt::Connect object.
+ * to open a connection to a URL.
  */
-VALUE libvirt_open(int argc, VALUE *argv, VALUE m) {
+static VALUE libvirt_open(int argc, VALUE *argv, VALUE m) {
     return internal_open(argc, argv, m, 0);
 }
 
 /*
  * call-seq:
- *   Libvirt::openReadOnly(url) -> Libvirt::Connect
+ *   Libvirt::open_read_only(uri=nil) -> Libvirt::Connect
  *
  * Call
  * +virConnectOpenReadOnly+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectOpenReadOnly]
- * to open a read-only connection to a URL.  Returns a new Libvirt::Connect
- * object.
+ * to open a read-only connection to a URL.
  */
-VALUE libvirt_open_read_only(int argc, VALUE *argv, VALUE m) {
+static VALUE libvirt_open_read_only(int argc, VALUE *argv, VALUE m) {
     return internal_open(argc, argv, m, 1);
 }
 
+#if HAVE_VIRCONNECTOPENAUTH
+static int libvirt_auth_callback_wrapper(virConnectCredentialPtr cred,
+                                         unsigned int ncred, void *cbdata) {
+    VALUE userdata;
+    VALUE newcred;
+    int i;
+    VALUE result;
+
+    userdata = (VALUE)cbdata;
+
+    if (!rb_block_given_p())
+        rb_raise(rb_eRuntimeError, "No block given, this should never happen!\n");
+
+    for (i = 0; i < ncred; i++) {
+        newcred = rb_hash_new();
+
+        rb_hash_aset(newcred, rb_str_new2("type"), INT2FIX(cred[i].type));
+        rb_hash_aset(newcred, rb_str_new2("prompt"),
+                     rb_str_new2(cred[i].prompt));
+        if (cred[i].challenge)
+            rb_hash_aset(newcred, rb_str_new2("challenge"),
+                         rb_str_new2(cred[i].challenge));
+        else
+            rb_hash_aset(newcred, rb_str_new2("challenge"), Qnil);
+        if (cred[i].defresult)
+            rb_hash_aset(newcred, rb_str_new2("defresult"),
+                         rb_str_new2(cred[i].defresult));
+        else
+            rb_hash_aset(newcred, rb_str_new2("defresult"), Qnil);
+        rb_hash_aset(newcred, rb_str_new2("result"), Qnil);
+        rb_hash_aset(newcred, rb_str_new2("userdata"), userdata);
+
+        result = rb_yield(newcred);
+        if (NIL_P(result)) {
+            cred[i].result = NULL;
+            cred[i].resultlen = 0;
+        }
+        else {
+            cred[i].result = strdup(StringValueCStr(result));
+            cred[i].resultlen = strlen(cred[i].result);
+        }
+    }
+
+    return 0;
+}
+
+
+struct wrap_callout {
+    char *uri;
+    virConnectAuthPtr auth;
+    unsigned int flags;
+};
+
+static VALUE rb_open_auth_wrap(VALUE arg) {
+    struct wrap_callout *e = (struct wrap_callout *)arg;
+
+    return (VALUE)virConnectOpenAuth(e->uri, e->auth, e->flags);
+}
+
+static VALUE rb_num2int_wrap(VALUE arg) {
+    return NUM2INT(arg);
+}
+
+/*
+ * call-seq:
+ *   Libvirt::open_auth(uri=nil, credlist=nil, userdata=nil, flags=0) {|...| authentication block} -> Libvirt::Connect
+ *
+ * Call
+ * +virConnectOpenAuth+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectOpenAuth]
+ * to open a connection to a libvirt URI, with a possible authentication block.
+ * If an authentication block is desired, then credlist should be an array that
+ * specifies which credentials the authentication block is willing to support;
+ * the full list is available at http://libvirt.org/html/libvirt-libvirt.html#virConnectCredentialType.
+ * If userdata is not nil and an authentication block is given, userdata will
+ * be passed unaltered into the authentication block.  The flags parameter
+ * controls how to open connection.  The only options currently available for
+ * flags are 0 for a read/write connection and Libvirt::CONNECT_RO for a
+ * read-only connection.
+ *
+ * If the credlist is not empty, and an authentication block is given, the
+ * authentication block will be called once for each credential necessary
+ * to complete the authentication.  The authentication block will be passed a
+ * single parameter, which is a hash of values containing information necessary
+ * to complete authentication.  This hash contains 5 elements:
+ *
+ * type - the type of credential to be examined
+ *
+ * prompt - a suggested prompt to show to the user
+ *
+ * challenge - any additional challenge information
+ *
+ * defresult - a default result to use if credentials could not be obtained
+ *
+ * userdata - the userdata passed into open_auth initially
+ *
+ * The authentication block should return the result of collecting the
+ * information; these results will then be sent to libvirt for authentication.
+ */
+static VALUE libvirt_open_auth(int argc, VALUE *argv, VALUE m) {
+    virConnectAuthPtr auth;
+    VALUE uri;
+    VALUE credlist;
+    VALUE userdata;
+    VALUE flags_val;
+    char *uri_c;
+    virConnectPtr conn = NULL;
+    unsigned int flags;
+    int auth_alloc;
+    int i;
+    VALUE tmp;
+    int exception = 0;
+    struct rb_ary_entry_arg args;
+    struct wrap_callout callargs;
+
+    rb_scan_args(argc, argv, "04", &uri, &credlist, &userdata, &flags_val);
+
+    /* handle the optional URI */
+    uri_c = get_string_or_nil(uri);
+
+    /* handle the optional flags */
+    if (NIL_P(flags_val))
+        flags = 0;
+    else
+        flags = NUM2UINT(flags_val);
+
+    if (rb_block_given_p()) {
+        auth = ALLOC(virConnectAuth);
+        auth_alloc = 1;
+
+        if (TYPE(credlist) == T_NIL)
+            auth->ncredtype = 0;
+        else if (TYPE(credlist) == T_ARRAY)
+            auth->ncredtype = RARRAY_LEN(credlist);
+        else
+            rb_raise(rb_eTypeError, "wrong argument type (expected Array or nil)");
+        auth->credtype = NULL;
+        if (auth->ncredtype > 0) {
+            /* we don't use ALLOC_N here because that can throw an exception,
+             * and leak the auth pointer.  Instead we use normal malloc
+             * (which has a slightly higher chance of returning NULL), and
+             * then properly cleanup if it fails
+             */
+            auth->credtype = malloc(sizeof(int) * auth->ncredtype);
+            if (auth->credtype == NULL) {
+                xfree(auth);
+                rb_memerror();
+            }
+            for (i = 0; i < auth->ncredtype; i++) {
+                args.arr = credlist;
+                args.elem = i;
+                tmp = rb_protect(rb_ary_entry_wrap, (VALUE)&args, &exception);
+                if (exception)
+                    goto do_cleanup;
+
+                auth->credtype[i] = rb_protect(rb_num2int_wrap, tmp,
+                                               &exception);
+                if (exception)
+                    goto do_cleanup;
+            }
+        }
+
+        auth->cb = libvirt_auth_callback_wrapper;
+        auth->cbdata = (void *)userdata;
+    }
+    else {
+        auth = virConnectAuthPtrDefault;
+        auth_alloc = 0;
+    }
+
+    callargs.uri = uri_c;
+    callargs.auth = auth;
+    callargs.flags = flags;
+
+    conn = (virConnectPtr)rb_protect(rb_open_auth_wrap, (VALUE)&callargs,
+                                     &exception);
+
+do_cleanup:
+    if (auth_alloc) {
+        free(auth->credtype);
+        xfree(auth);
+    }
+
+    if (exception)
+        rb_jump_tag(exception);
+
+    _E(conn == NULL, create_error(e_ConnectionError, "virConnectOpenAuth",
+                                  NULL));
+
+    return connect_new(conn);
+}
+#endif
+
+#if HAVE_VIREVENTREGISTERIMPL
+static VALUE add_handle, update_handle, remove_handle;
+static VALUE add_timeout, update_timeout, remove_timeout;
+
+/*
+ * call-seq:
+ *   Libvirt::event_invoke_handle_callback(handle, fd, events, opaque) -> Qnil
+ *
+ * Unlike most of the other functions in the ruby-libvirt bindings, this one
+ * does not directly correspond to a libvirt API function.  Instead, this
+ * module method (and event_invoke_timeout_callback) are meant to be called
+ * when there is an event of interest to libvirt on one of the file descriptors
+ * that libvirt uses.  The application is notified of the file descriptors
+ * that libvirt uses via the callbacks from Libvirt::event_register_impl.  When
+ * there is an event of interest, the application must call
+ * event_invoke_timeout_callback to ensure proper operation.
+ *
+ * Libvirt::event_invoke_handle_callback takes 4 arguments:
+ *
+ * handle
+ *          an application specific handle ID.  This can be any integer, but
+ *          must be unique from all other libvirt handles in the application.
+ * fd
+ *          the file descriptor of interest.  This was given to the application
+ *          as a callback to add_handle of Libvirt::event_register_impl
+ * events
+ *          the events that have occured on the fd.  Note that the events are
+ *          libvirt specific, and are some combination of
+ *          Libvirt::EVENT_HANDLE_READABLE, Libvirt::EVENT_HANDLE_WRITABLE,
+ *          Libvirt::EVENT_HANDLE_ERROR, Libvirt::EVENT_HANDLE_HANGUP.  To
+ *          notify libvirt of more than one event at a time, these values should
+ *          be logically OR'ed together.
+ * opaque
+ *          the opaque data passed from libvirt during the
+ *          Libvirt::event_register_impl add_handle callback.  To ensure proper
+ *          operation this data must be passed through to
+ *          event_invoke_handle_callback without modification.
+ */
+static VALUE libvirt_event_invoke_handle_callback(VALUE m, VALUE handle,
+                                                  VALUE fd, VALUE events,
+                                                  VALUE opaque) {
+    virEventHandleCallback cb;
+    void *op;
+    VALUE libvirt_cb;
+    VALUE libvirt_opaque;
+
+    if (TYPE(opaque) != T_HASH)
+        rb_raise(rb_eTypeError,
+                 "wrong event callback argument type (expected Hash)");
+
+    libvirt_cb = rb_hash_aref(opaque, rb_str_new2("libvirt_cb"));
+
+    /* This is equivalent to Data_Get_Struct; I reproduce it here because
+     * I don't want the additional type-cast that Data_Get_Struct does
+     */
+    Check_Type(libvirt_cb, T_DATA);
+    cb = DATA_PTR(libvirt_cb);
+
+    if (cb) {
+        libvirt_opaque = rb_hash_aref(opaque, rb_str_new2("opaque"));
+        Data_Get_Struct(libvirt_opaque, void *, op);
+        cb(NUM2INT(handle), NUM2INT(fd), NUM2INT(events), op);
+    }
+
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   Libvirt::event_invoke_timeout_callback(timer, opaque) -> Qnil
+ *
+ * Unlike most of the other functions in the ruby-libvirt bindings, this one
+ * does not directly correspond to a libvirt API function.  Instead, this
+ * module method (and event_invoke_handle_callback) are meant to be called
+ * when there is a timeout of interest to libvirt.  The application is
+ * notified of the timers that libvirt uses via the callbacks from
+ * Libvirt::event_register_impl.  When a timeout expires, the application must
+ * call event_invoke_timeout_callback to ensure proper operation.
+ *
+ * Libvirt::event_invoke_timeout_callback takes 2 arguments:
+ *
+ * handle
+ *          an application specific timer ID.  This can be any integer, but
+ *          must be unique from all other libvirt timers in the application.
+ * opaque
+ *          the opaque data passed from libvirt during the
+ *          Libvirt::event_register_impl add_handle callback.  To ensure proper
+ *          operation this data must be passed through to
+ *          event_invoke_handle_callback without modification.
+ */
+static VALUE libvirt_event_invoke_timeout_callback(VALUE m, VALUE timer,
+                                                   VALUE opaque) {
+    virEventTimeoutCallback cb;
+    void *op;
+    VALUE libvirt_cb;
+    VALUE libvirt_opaque;
+
+    if (TYPE(opaque) != T_HASH)
+        rb_raise(rb_eTypeError,
+                 "wrong event callback argument type (expected Hash)");
+
+    libvirt_cb = rb_hash_aref(opaque, rb_str_new2("libvirt_cb"));
+
+    /* This is equivalent to Data_Get_Struct; I reproduce it here because
+     * I don't want the additional type-cast that Data_Get_Struct does
+     */
+    Check_Type(libvirt_cb, T_DATA);
+    cb = DATA_PTR(libvirt_cb);
+
+    if (cb) {
+        libvirt_opaque = rb_hash_aref(opaque, rb_str_new2("opaque"));
+        Data_Get_Struct(libvirt_opaque, void *, op);
+        cb(NUM2INT(timer), op);
+    }
+
+    return Qnil;
+}
+
+static int internal_add_handle_func(int fd, int events,
+                                    virEventHandleCallback cb, void *opaque,
+                                    virFreeCallback ff) {
+    VALUE rubyargs;
+    VALUE res;
+
+    rubyargs = rb_hash_new();
+    rb_hash_aset(rubyargs, rb_str_new2("libvirt_cb"),
+                 Data_Wrap_Struct(rb_class_of(add_handle), NULL, NULL, cb));
+    rb_hash_aset(rubyargs, rb_str_new2("opaque"),
+                 Data_Wrap_Struct(rb_class_of(add_handle), NULL, NULL, opaque));
+    rb_hash_aset(rubyargs, rb_str_new2("free_func"),
+                 Data_Wrap_Struct(rb_class_of(add_handle), NULL, NULL, ff));
+
+    /* call out to the ruby object */
+    if (strcmp(rb_obj_classname(add_handle), "Symbol") == 0)
+        res = rb_funcall(rb_class_of(add_handle), rb_to_id(add_handle), 3,
+                         INT2FIX(fd), INT2FIX(events), rubyargs);
+    else if (strcmp(rb_obj_classname(add_handle), "Proc") == 0)
+        res = rb_funcall(add_handle, rb_intern("call"), 3, INT2FIX(fd),
+                         INT2FIX(events), rubyargs);
+    else
+        rb_raise(rb_eTypeError,
+                 "wrong add handle callback argument type (expected Symbol or Proc)");
+
+    if (TYPE(res) != T_FIXNUM)
+        rb_raise(rb_eTypeError,
+                 "expected integer return from add_handle callback");
+
+    return NUM2INT(res);
+}
+
+static void internal_update_handle_func(int watch, int event) {
+    /* call out to the ruby object */
+    if (strcmp(rb_obj_classname(update_handle), "Symbol") == 0)
+        rb_funcall(rb_class_of(update_handle), rb_to_id(update_handle), 2,
+                   INT2FIX(watch), INT2FIX(event));
+    else if (strcmp(rb_obj_classname(update_handle), "Proc") == 0)
+        rb_funcall(update_handle, rb_intern("call"), 2, INT2FIX(watch),
+                   INT2FIX(event));
+    else
+        rb_raise(rb_eTypeError,
+                 "wrong update handle callback argument type (expected Symbol or Proc)");
+}
+
+static int internal_remove_handle_func(int watch) {
+    VALUE res;
+    virFreeCallback ff_cb;
+    void *op;
+    VALUE libvirt_opaque;
+    VALUE ff;
+
+    /* call out to the ruby object */
+    if (strcmp(rb_obj_classname(remove_handle), "Symbol") == 0)
+        res = rb_funcall(rb_class_of(remove_handle), rb_to_id(remove_handle),
+                         1, INT2FIX(watch));
+    else if (strcmp(rb_obj_classname(remove_handle), "Proc") == 0)
+        res = rb_funcall(remove_handle, rb_intern("call"), 1, INT2FIX(watch));
+    else
+        rb_raise(rb_eTypeError,
+                 "wrong remove handle callback argument type (expected Symbol or Proc)");
+
+    if (TYPE(res) != T_HASH)
+        rb_raise(rb_eTypeError,
+                 "expected opaque hash returned from remove_handle callback");
+
+    ff = rb_hash_aref(res, rb_str_new2("free_func"));
+    if (!NIL_P(ff)) {
+        /* This is equivalent to Data_Get_Struct; I reproduce it here because
+         * I don't want the additional type-cast that Data_Get_Struct does
+         */
+        Check_Type(ff, T_DATA);
+        ff_cb = DATA_PTR(ff);
+        if (ff_cb) {
+            libvirt_opaque = rb_hash_aref(res, rb_str_new2("opaque"));
+            Data_Get_Struct(libvirt_opaque, void *, op);
+
+            (*ff_cb)(op);
+        }
+    }
+
+    return 0;
+}
+
+static int internal_add_timeout_func(int interval, virEventTimeoutCallback cb,
+                                     void *opaque, virFreeCallback ff) {
+    VALUE rubyargs;
+    VALUE res;
+
+    rubyargs = rb_hash_new();
+
+    rb_hash_aset(rubyargs, rb_str_new2("libvirt_cb"),
+                 Data_Wrap_Struct(rb_class_of(add_timeout), NULL, NULL, cb));
+    rb_hash_aset(rubyargs, rb_str_new2("opaque"),
+                 Data_Wrap_Struct(rb_class_of(add_timeout), NULL, NULL,
+                                  opaque));
+    rb_hash_aset(rubyargs, rb_str_new2("free_func"),
+                 Data_Wrap_Struct(rb_class_of(add_timeout), NULL, NULL, ff));
+
+    /* call out to the ruby object */
+    if (strcmp(rb_obj_classname(add_timeout), "Symbol") == 0)
+        res = rb_funcall(rb_class_of(add_timeout), rb_to_id(add_timeout), 2,
+                         INT2FIX(interval), rubyargs);
+    else if (strcmp(rb_obj_classname(add_timeout), "Proc") == 0)
+        res = rb_funcall(add_timeout, rb_intern("call"), 2, INT2FIX(interval),
+                         rubyargs);
+    else
+        rb_raise(rb_eTypeError,
+                 "wrong add timeout callback argument type (expected Symbol or Proc)");
+
+    if (TYPE(res) != T_FIXNUM)
+        rb_raise(rb_eTypeError,
+                 "expected integer return from add_timeout callback");
+
+    return NUM2INT(res);
+}
+
+static void internal_update_timeout_func(int timer, int timeout) {
+    /* call out to the ruby object */
+    if (strcmp(rb_obj_classname(update_timeout), "Symbol") == 0)
+        rb_funcall(rb_class_of(update_timeout), rb_to_id(update_timeout), 2,
+                   INT2FIX(timer), INT2FIX(timeout));
+    else if (strcmp(rb_obj_classname(update_timeout), "Proc") == 0)
+        rb_funcall(update_timeout, rb_intern("call"), 2, INT2FIX(timer),
+                   INT2FIX(timeout));
+    else
+        rb_raise(rb_eTypeError,
+                 "wrong update timeout callback argument type (expected Symbol or Proc)");
+}
+
+static int internal_remove_timeout_func(int timer) {
+    VALUE res;
+    virFreeCallback ff_cb;
+    void *op;
+    VALUE libvirt_opaque;
+    VALUE ff;
+
+    /* call out to the ruby object */
+    if (strcmp(rb_obj_classname(remove_timeout), "Symbol") == 0)
+        res = rb_funcall(rb_class_of(remove_timeout), rb_to_id(remove_timeout),
+                         1, INT2FIX(timer));
+    else if (strcmp(rb_obj_classname(remove_timeout), "Proc") == 0)
+        res = rb_funcall(remove_timeout, rb_intern("call"), 1, INT2FIX(timer));
+    else
+        rb_raise(rb_eTypeError,
+                 "wrong remove timeout callback argument type (expected Symbol or Proc)");
+
+    if (TYPE(res) != T_HASH)
+        rb_raise(rb_eTypeError,
+                 "expected opaque hash returned from remove_timeout callback");
+
+    ff = rb_hash_aref(res, rb_str_new2("free_func"));
+    if (!NIL_P(ff)) {
+        /* This is equivalent to Data_Get_Struct; I reproduce it here because
+         * I don't want the additional type-cast that Data_Get_Struct does
+         */
+        Check_Type(ff, T_DATA);
+        ff_cb = DATA_PTR(ff);
+        if (ff_cb) {
+            libvirt_opaque = rb_hash_aref(res, rb_str_new2("opaque"));
+            Data_Get_Struct(libvirt_opaque, void *, op);
+
+            (*ff_cb)(op);
+        }
+    }
+
+    return 0;
+}
+
+#define set_event_func_or_null(type)                \
+    do {                                            \
+        if (NIL_P(type))                            \
+            type##_temp = NULL;                     \
+        else                                        \
+            type##_temp = internal_##type##_func;   \
+    } while(0)
+
+static int is_symbol_proc_or_nil(VALUE handle) {
+    if (NIL_P(handle))
+        return 1;
+    return is_symbol_or_proc(handle);
+}
+
+/*
+ * call-seq:
+ *   Libvirt::event_register_impl(add_handle=nil, update_handle=nil, remove_handle=nil, add_timeout=nil, update_timeout=nil, remove_timeout=nil) -> Qnil
+ *
+ * Call
+ * +virEventRegisterImpl+[http://www.libvirt.org/html/libvirt-libvirt.html#virEventRegisterImpl]
+ * to register callback handlers for handles and timeouts.  These handles and
+ * timeouts are used as part of the libvirt infrastructure for generating
+ * domain events.  Each callback must be a Symbol (that is the name of a
+ * method to callback), a Proc, or nil (to disable the callback).  In the
+ * end-user application program, these callbacks are typically used to track
+ * the file descriptors or timers that libvirt is interested in (and is intended
+ * to be integrated into the "main loop" of a UI program).  The individual
+ * callbacks will be given a certain number of arguments, and must return
+ * certain values.  Those arguments and return types are:
+ *
+ * add_handle(fd, events, opaque) => Fixnum
+ *
+ * update_handle(handleID, event) => nil
+ *
+ * remove_handle(handleID) => opaque data from add_handle
+ *
+ * add_timeout(interval, opaque) => Fixnum
+ *
+ * update_timeout(timerID, timeout) => nil
+ *
+ * remove_timeout(timerID) => opaque data from add_timeout
+ *
+ * Any arguments marked as "opaque" must be accepted from the library and saved
+ * without modification.  The values passed to the callbacks are meant to be
+ * passed to the event_invoke_handle_callback and event_invoke_timeout_callback
+ * module methods; see the documentation for those methods for more details.
+ */
+static VALUE libvirt_conn_event_register_impl(int argc, VALUE *argv, VALUE c) {
+    virEventAddHandleFunc add_handle_temp;
+    virEventUpdateHandleFunc update_handle_temp;
+    virEventRemoveHandleFunc remove_handle_temp;
+    virEventAddTimeoutFunc add_timeout_temp;
+    virEventUpdateTimeoutFunc update_timeout_temp;
+    virEventRemoveTimeoutFunc remove_timeout_temp;
+
+    /*
+     * subtle; we put the arguments (callbacks) directly into the global
+     * add_handle, update_handle, etc. variables.  Then we register the
+     * internal functions as the callbacks with virEventRegisterImpl
+     */
+    rb_scan_args(argc, argv, "06", &add_handle, &update_handle, &remove_handle,
+                 &add_timeout, &update_timeout, &remove_timeout);
+
+    if (!is_symbol_proc_or_nil(add_handle) ||
+        !is_symbol_proc_or_nil(update_handle) ||
+        !is_symbol_proc_or_nil(remove_handle) ||
+        !is_symbol_proc_or_nil(add_timeout) ||
+        !is_symbol_proc_or_nil(update_timeout) ||
+        !is_symbol_proc_or_nil(remove_timeout))
+        rb_raise(rb_eTypeError,
+                 "wrong argument type (expected Symbol, Proc, or nil)");
+
+    set_event_func_or_null(add_handle);
+    set_event_func_or_null(update_handle);
+    set_event_func_or_null(remove_handle);
+    set_event_func_or_null(add_timeout);
+    set_event_func_or_null(update_timeout);
+    set_event_func_or_null(remove_timeout);
+
+    /* virEventRegisterImpl returns void, so no error checking here */
+    virEventRegisterImpl(add_handle_temp, update_handle_temp,
+                         remove_handle_temp, add_timeout_temp,
+                         update_timeout_temp, remove_timeout_temp);
+
+    return Qnil;
+}
+#endif
+
 /*
  * Module Libvirt
  */
 void Init__libvirt() {
-    int r;
-
     m_libvirt = rb_define_module("Libvirt");
     c_libvirt_version = rb_define_class_under(m_libvirt, "Version",
                                               rb_cObject);
 
+#if HAVE_VIRCONNECTOPENAUTH
+    rb_define_const(m_libvirt, "CONNECT_RO", INT2NUM(VIR_CONNECT_RO));
+
+    rb_define_const(m_libvirt, "CRED_USERNAME", INT2NUM(VIR_CRED_USERNAME));
+    rb_define_const(m_libvirt, "CRED_AUTHNAME", INT2NUM(VIR_CRED_AUTHNAME));
+    rb_define_const(m_libvirt, "CRED_LANGUAGE", INT2NUM(VIR_CRED_LANGUAGE));
+    rb_define_const(m_libvirt, "CRED_CNONCE", INT2NUM(VIR_CRED_CNONCE));
+    rb_define_const(m_libvirt, "CRED_PASSPHRASE", INT2NUM(VIR_CRED_PASSPHRASE));
+    rb_define_const(m_libvirt, "CRED_ECHOPROMPT", INT2NUM(VIR_CRED_ECHOPROMPT));
+    rb_define_const(m_libvirt, "CRED_NOECHOPROMPT", INT2NUM(VIR_CRED_NOECHOPROMPT));
+    rb_define_const(m_libvirt, "CRED_REALM", INT2NUM(VIR_CRED_REALM));
+    rb_define_const(m_libvirt, "CRED_EXTERNAL", INT2NUM(VIR_CRED_EXTERNAL));
+#endif
 
     /*
      * Libvirt Errors
@@ -144,17 +725,45 @@ void Init__libvirt() {
                                               e_Error);
     e_RetrieveError =   rb_define_class_under(m_libvirt, "RetrieveError",
                                               e_Error);
+    e_NoSupportError =  rb_define_class_under(m_libvirt, "NoSupportError",
+                                              e_Error);
 
-    // create 'libvirt_function_name' and 'vir_connect_ptr' attributes on e_Error class
     rb_define_attr(e_Error, "libvirt_function_name", 1, 0);
     rb_define_attr(e_Error, "libvirt_message", 1, 0);
 
     rb_define_module_function(m_libvirt, "version", libvirt_version, -1);
-	rb_define_module_function(m_libvirt, "open", libvirt_open, -1);
-	rb_define_module_function(m_libvirt, "open_read_only",
+    rb_define_module_function(m_libvirt, "open", libvirt_open, -1);
+    rb_define_module_function(m_libvirt, "open_read_only",
                               libvirt_open_read_only, -1);
-    // FIXME: implement this
-    //rb_define_module_function(m_libvirt, "open_auth", libvirt_open_auth, -1);
+#if HAVE_VIRCONNECTOPENAUTH
+    rb_define_module_function(m_libvirt, "open_auth", libvirt_open_auth, -1);
+#endif
+
+#if HAVE_VIREVENTREGISTERIMPL
+    rb_define_const(m_libvirt, "EVENT_HANDLE_READABLE",
+                    INT2NUM(VIR_EVENT_HANDLE_READABLE));
+    rb_define_const(m_libvirt, "EVENT_HANDLE_WRITABLE",
+                    INT2NUM(VIR_EVENT_HANDLE_WRITABLE));
+    rb_define_const(m_libvirt, "EVENT_HANDLE_ERROR",
+                    INT2NUM(VIR_EVENT_HANDLE_ERROR));
+    rb_define_const(m_libvirt, "EVENT_HANDLE_HANGUP",
+                    INT2NUM(VIR_EVENT_HANDLE_HANGUP));
+
+    /* since we are using globals, we have to register with the gc */
+    rb_global_variable(&add_handle);
+    rb_global_variable(&update_handle);
+    rb_global_variable(&remove_handle);
+    rb_global_variable(&add_timeout);
+    rb_global_variable(&update_timeout);
+    rb_global_variable(&remove_timeout);
+
+    rb_define_module_function(m_libvirt, "event_register_impl",
+                              libvirt_conn_event_register_impl, -1);
+    rb_define_module_function(m_libvirt, "event_invoke_handle_callback",
+                              libvirt_event_invoke_handle_callback, 4);
+    rb_define_module_function(m_libvirt, "event_invoke_timeout_callback",
+                              libvirt_event_invoke_timeout_callback, 2);
+#endif
 
     init_connect();
     init_storage();
@@ -165,16 +774,8 @@ void Init__libvirt() {
     init_interface();
     init_domain();
 
-    r = virInitialize();
-    if (r < 0)
+    virSetErrorFunc(NULL, rubyLibvirtErrorFunc);
+
+    if (virInitialize() < 0)
         rb_raise(rb_eSystemCallError, "virInitialize failed");
 }
-
-/*
- * Local variables:
- *  indent-tabs-mode: nil
- *  c-indent-level: 4
- *  c-basic-offset: 4
- *  tab-width: 4
- * End:
- */