ruby-libvirt-catphish 0.7.1

data/ext/libvirt/storage.h

@@ -0,0 +1,6 @@
+#ifndef STORAGE_H
+#define STORAGE_H
+
+void ruby_libvirt_storage_init(void);
+
+#endif

data/ext/libvirt/stream.c

@@ -0,0 +1,392 @@
+/*
+ * stream.c: virStream methods
+ *
+ * Copyright (C) 2007,2010 Red Hat Inc.
+ * Copyright (C) 2013-2016 Chris Lalancette <clalancette@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ */
+
+#include <ruby.h>
+#include <libvirt/libvirt.h>
+#include <libvirt/virterror.h>
+#include "common.h"
+#include "connect.h"
+#include "extconf.h"
+
+#if HAVE_TYPE_VIRSTREAMPTR
+static VALUE c_stream;
+
+static void stream_free(void *s)
+{
+    ruby_libvirt_free_struct(Stream, s);
+}
+
+virStreamPtr ruby_libvirt_stream_get(VALUE s)
+{
+    ruby_libvirt_get_struct(Stream, s);
+}
+
+VALUE ruby_libvirt_stream_new(virStreamPtr s, VALUE conn)
+{
+    return ruby_libvirt_new_class(c_stream, s, conn, stream_free);
+}
+
+/*
+ * call-seq:
+ *   stream.send(buffer) -> Fixnum
+ *
+ * Call virStreamSend[http://www.libvirt.org/html/libvirt-libvirt-stream.html#virStreamSend]
+ * to send the data in buffer out to the stream.  The return value is the
+ * number of bytes sent, which may be less than the size of the buffer.  If
+ * an error occurred, -1 is returned.  If the transmit buffers are full and the
+ * stream is marked non-blocking, returns -2.
+ */
+static VALUE libvirt_stream_send(VALUE s, VALUE buffer)
+{
+    int ret;
+
+    StringValue(buffer);
+
+    ret = virStreamSend(ruby_libvirt_stream_get(s), RSTRING_PTR(buffer),
+                        RSTRING_LEN(buffer));
+    ruby_libvirt_raise_error_if(ret == -1, e_RetrieveError, "virStreamSend",
+                                ruby_libvirt_connect_get(s));
+
+    return INT2NUM(ret);
+}
+
+/*
+ * call-seq:
+ *   stream.recv(bytes) -> [return_value, data]
+ *
+ * Call virStreamRecv[http://www.libvirt.org/html/libvirt-libvirt-stream.html#virStreamRecv]
+ * to receive up to bytes amount of data from the stream.  The return is an
+ * array with two elements; the return code from the virStreamRecv call and
+ * the data (as a String) read from the stream.  If an error occurred, the
+ * return_value is set to -1.  If there is no data pending and the stream is
+ * marked as non-blocking, return_value is set to -2.
+ */
+static VALUE libvirt_stream_recv(VALUE s, VALUE bytes)
+{
+    char *data;
+    int ret;
+    VALUE result;
+
+    data = alloca(sizeof(char) * NUM2INT(bytes));
+
+    ret = virStreamRecv(ruby_libvirt_stream_get(s), data, NUM2INT(bytes));
+    ruby_libvirt_raise_error_if(ret < 0, e_RetrieveError, "virStreamRecv",
+                                ruby_libvirt_connect_get(s));
+
+    result = rb_ary_new2(2);
+
+    rb_ary_store(result, 0, INT2NUM(ret));
+    rb_ary_store(result, 1, rb_str_new(data, ret));
+
+    return result;
+}
+
+static int internal_sendall(virStreamPtr RUBY_LIBVIRT_UNUSED(st), char *data,
+                            size_t nbytes, void *opaque)
+{
+    VALUE result, retcode, buffer;
+
+    result = rb_yield_values(2, (VALUE)opaque, INT2NUM(nbytes));
+
+    if (TYPE(result) != T_ARRAY) {
+        rb_raise(rb_eTypeError, "wrong type (expected Array)");
+    }
+
+    if (RARRAY_LEN(result) != 2) {
+        rb_raise(rb_eArgError, "wrong number of arguments (%ld for 2)",
+                 RARRAY_LEN(result));
+    }
+
+    retcode = rb_ary_entry(result, 0);
+    buffer = rb_ary_entry(result, 1);
+
+    if (NUM2INT(retcode) < 0) {
+        return NUM2INT(retcode);
+    }
+
+    StringValue(buffer);
+
+    if (RSTRING_LEN(buffer) > (int)nbytes) {
+        rb_raise(rb_eArgError, "asked for %zd bytes, block returned %ld",
+                 nbytes, RSTRING_LEN(buffer));
+    }
+
+    memcpy(data, RSTRING_PTR(buffer), RSTRING_LEN(buffer));
+
+    return RSTRING_LEN(buffer);
+}
+
+/*
+ * call-seq:
+ *   stream.sendall(opaque=nil){|opaque, nbytes| send block} -> nil
+ *
+ * Call virStreamSendAll[http://www.libvirt.org/html/libvirt-libvirt-stream.html#virStreamSendAll]
+ * to send the entire data stream.  The send block is required and is executed
+ * one or more times to send data.  Each invocation of the send block yields
+ * the opaque data passed into the initial call and the number of bytes this
+ * iteration is prepared to handle.  The send block should return an array of
+ * 2 elements; the first element should be the return code from the block
+ * (-1 for error, 0 otherwise), and the second element should be the data
+ * that the block prepared to send.
+ */
+static VALUE libvirt_stream_sendall(int argc, VALUE *argv, VALUE s)
+{
+    VALUE opaque = RUBY_Qnil;
+    int ret;
+
+    if (!rb_block_given_p()) {
+        rb_raise(rb_eRuntimeError, "A block must be provided");
+    }
+
+    rb_scan_args(argc, argv, "01", &opaque);
+
+    ret = virStreamSendAll(ruby_libvirt_stream_get(s), internal_sendall,
+                           (void *)opaque);
+    ruby_libvirt_raise_error_if(ret < 0, e_RetrieveError, "virStreamSendAll",
+                                ruby_libvirt_connect_get(s));
+
+    return Qnil;
+}
+
+static int internal_recvall(virStreamPtr RUBY_LIBVIRT_UNUSED(st),
+                            const char *buf, size_t nbytes, void *opaque)
+{
+    VALUE result;
+
+    result = rb_yield_values(2, rb_str_new(buf, nbytes), (VALUE)opaque);
+
+    if (TYPE(result) != T_FIXNUM) {
+        rb_raise(rb_eArgError, "wrong type (expected an integer)");
+    }
+
+    return NUM2INT(result);
+}
+
+/*
+ * call-seq:
+ *   stream.recvall(opaque){|data, opaque| receive block} -> nil
+ *
+ * Call virStreamRecvAll[http://www.libvirt.org/html/libvirt-libvirt-stream.html#virStreamRecvAll]
+ * to receive the entire data stream.  The receive block is required and is
+ * called one or more times to receive data.  Each invocation of the receive
+ * block yields the data received and the opaque data passed into the initial
+ * call.  The block should return -1 if an error occurred and 0 otherwise.
+ */
+static VALUE libvirt_stream_recvall(int argc, VALUE *argv, VALUE s)
+{
+    VALUE opaque = RUBY_Qnil;
+    int ret;
+
+    if (!rb_block_given_p()) {
+        rb_raise(rb_eRuntimeError, "A block must be provided");
+    }
+
+    rb_scan_args(argc, argv, "01", &opaque);
+
+    ret = virStreamRecvAll(ruby_libvirt_stream_get(s), internal_recvall,
+                           (void *)opaque);
+    ruby_libvirt_raise_error_if(ret < 0, e_RetrieveError, "virStreamRecvAll",
+                                ruby_libvirt_connect_get(s));
+
+    return Qnil;
+}
+
+static void stream_event_callback(virStreamPtr st, int events, void *opaque)
+{
+    VALUE passthrough = (VALUE)opaque;
+    VALUE cb, cb_opaque, news, s;
+
+    if (TYPE(passthrough) != T_ARRAY) {
+        rb_raise(rb_eTypeError,
+                 "wrong domain event lifecycle callback argument type (expected Array)");
+    }
+
+    if (RARRAY_LEN(passthrough) != 3) {
+        rb_raise(rb_eArgError, "wrong number of arguments (%ld for 3)",
+                 RARRAY_LEN(passthrough));
+    }
+
+    cb = rb_ary_entry(passthrough, 0);
+    cb_opaque = rb_ary_entry(passthrough, 1);
+    s = rb_ary_entry(passthrough, 2);
+
+    news = ruby_libvirt_stream_new(st, ruby_libvirt_conn_attr(s));
+    if (strcmp(rb_obj_classname(cb), "Symbol") == 0) {
+        rb_funcall(rb_class_of(cb), rb_to_id(cb), 3, news, INT2NUM(events),
+                   cb_opaque);
+    }
+    else if (strcmp(rb_obj_classname(cb), "Proc") == 0) {
+        rb_funcall(cb, rb_intern("call"), 3, news, INT2NUM(events), cb_opaque);
+    }
+    else {
+        rb_raise(rb_eTypeError,
+                 "wrong stream event callback (expected Symbol or Proc)");
+    }
+}
+
+/*
+ * call-seq:
+ *   stream.event_add_callback(events, callback, opaque=nil) -> nil
+ *
+ * Call virStreamEventAddCallback[http://www.libvirt.org/html/libvirt-libvirt-stream.html#virStreamEventAddCallback]
+ * to register a callback to be notified when a stream becomes readable or
+ * writeable.  The events parameter is an integer representing the events the
+ * user is interested in; it should be one or more of EVENT_READABLE,
+ * EVENT_WRITABLE, EVENT_ERROR, and EVENT_HANGUP, ORed together.  The callback
+ * can either be a Symbol (that is the name of a method to callback) or a Proc.
+ * The callback should accept 3 parameters: a pointer to the Stream object
+ * itself, the integer that represents the events that actually occurred, and
+ * an opaque pointer that was (optionally) passed into
+ * stream.event_add_callback to begin with.
+ */
+static VALUE libvirt_stream_event_add_callback(int argc, VALUE *argv, VALUE s)
+{
+    VALUE events = RUBY_Qnil, callback = RUBY_Qnil, opaque = RUBY_Qnil, passthrough;
+    int ret;
+
+    rb_scan_args(argc, argv, "21", &events, &callback, &opaque);
+
+    if (!ruby_libvirt_is_symbol_or_proc(callback)) {
+        rb_raise(rb_eTypeError,
+                 "wrong argument type (expected Symbol or Proc)");
+    }
+
+    passthrough = rb_ary_new2(3);
+    rb_ary_store(passthrough, 0, callback);
+    rb_ary_store(passthrough, 1, opaque);
+    rb_ary_store(passthrough, 2, s);
+
+    ret = virStreamEventAddCallback(ruby_libvirt_stream_get(s), NUM2INT(events),
+                                    stream_event_callback, (void *)passthrough,
+                                    NULL);
+    ruby_libvirt_raise_error_if(ret < 0, e_RetrieveError,
+                                "virStreamEventAddCallback",
+                                ruby_libvirt_connect_get(s));
+
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   stream.event_update_callback(events) -> nil
+ *
+ * Call virStreamEventUpdateCallback[http://www.libvirt.org/html/libvirt-libvirt-stream.html#virStreamEventUpdateCallback]
+ * to change the events that the event callback is looking for.  The events
+ * parameter is an integer representing the events the user is interested in;
+ * it should be one or more of EVENT_READABLE, EVENT_WRITABLE, EVENT_ERROR,
+ * and EVENT_HANGUP, ORed together.
+ */
+static VALUE libvirt_stream_event_update_callback(VALUE s, VALUE events)
+{
+    ruby_libvirt_generate_call_nil(virStreamEventUpdateCallback,
+                                   ruby_libvirt_connect_get(s),
+                                   ruby_libvirt_stream_get(s), NUM2INT(events));
+}
+
+/*
+ * call-seq:
+ *   stream.event_remove_callback -> nil
+ *
+ * Call virStreamEventRemoveCallback[http://www.libvirt.org/html/libvirt-libvirt-stream.html#virStreamEventRemoveCallback]
+ * to remove the event callback currently registered to this stream.
+ */
+static VALUE libvirt_stream_event_remove_callback(VALUE s)
+{
+    ruby_libvirt_generate_call_nil(virStreamEventRemoveCallback,
+                                   ruby_libvirt_connect_get(s),
+                                   ruby_libvirt_stream_get(s));
+}
+
+/*
+ * call-seq:
+ *   stream.finish -> nil
+ *
+ * Call virStreamFinish[http://www.libvirt.org/html/libvirt-libvirt-stream.html#virStreamFinish]
+ * to finish this stream.  Finish is typically used when the stream is no
+ * longer needed and needs to be cleaned up.
+ */
+static VALUE libvirt_stream_finish(VALUE s)
+{
+    ruby_libvirt_generate_call_nil(virStreamFinish, ruby_libvirt_connect_get(s),
+                                   ruby_libvirt_stream_get(s));
+}
+
+/*
+ * call-seq:
+ *   stream.abort -> nil
+ *
+ * Call virStreamAbort[http://www.libvirt.org/html/libvirt-libvirt-stream.html#virStreamAbort]
+ * to abort this stream.  Abort is typically used when something on the stream
+ * has failed, and the stream needs to be cleaned up.
+ */
+static VALUE libvirt_stream_abort(VALUE s)
+{
+    ruby_libvirt_generate_call_nil(virStreamAbort, ruby_libvirt_connect_get(s),
+                                   ruby_libvirt_stream_get(s));
+}
+
+/*
+ * call-seq:
+ *   stream.free -> nil
+ *
+ * Call virStreamFree[http://www.libvirt.org/html/libvirt-libvirt-stream.html#virStreamFree]
+ * to free this stream.  The object will no longer be valid after this call.
+ */
+static VALUE libvirt_stream_free(VALUE s)
+{
+    ruby_libvirt_generate_call_free(Stream, s);
+}
+#endif
+
+/*
+ * Class Libvirt::Stream
+ */
+void ruby_libvirt_stream_init(void)
+{
+#if HAVE_TYPE_VIRSTREAMPTR
+    c_stream = rb_define_class_under(m_libvirt, "Stream", rb_cObject);
+
+    rb_define_attr(c_stream, "connection", 1, 0);
+
+    rb_define_const(c_stream, "NONBLOCK", INT2NUM(VIR_STREAM_NONBLOCK));
+    rb_define_const(c_stream, "EVENT_READABLE",
+                    INT2NUM(VIR_STREAM_EVENT_READABLE));
+    rb_define_const(c_stream, "EVENT_WRITABLE",
+                    INT2NUM(VIR_STREAM_EVENT_WRITABLE));
+    rb_define_const(c_stream, "EVENT_ERROR", INT2NUM(VIR_STREAM_EVENT_ERROR));
+    rb_define_const(c_stream, "EVENT_HANGUP", INT2NUM(VIR_STREAM_EVENT_HANGUP));
+
+    rb_define_method(c_stream, "send", libvirt_stream_send, 1);
+    rb_define_method(c_stream, "recv", libvirt_stream_recv, 1);
+    rb_define_method(c_stream, "sendall", libvirt_stream_sendall, -1);
+    rb_define_method(c_stream, "recvall", libvirt_stream_recvall, -1);
+
+    rb_define_method(c_stream, "event_add_callback",
+                     libvirt_stream_event_add_callback, -1);
+    rb_define_method(c_stream, "event_update_callback",
+                     libvirt_stream_event_update_callback, 1);
+    rb_define_method(c_stream, "event_remove_callback",
+                     libvirt_stream_event_remove_callback, 0);
+    rb_define_method(c_stream, "finish", libvirt_stream_finish, 0);
+    rb_define_method(c_stream, "abort", libvirt_stream_abort, 0);
+    rb_define_method(c_stream, "free", libvirt_stream_free, 0);
+#endif
+}

data/ext/libvirt/stream.h

@@ -0,0 +1,9 @@
+#ifndef STREAM_H
+#define STREAM_H
+
+void ruby_libvirt_stream_init(void);
+
+VALUE ruby_libvirt_stream_new(virStreamPtr s, VALUE conn);
+virStreamPtr ruby_libvirt_stream_get(VALUE s);
+
+#endif

data/lib/libvirt.rb

@@ -0,0 +1,40 @@
+#
+# libvirt.rb: main module for the ruby-libvirt bindings
+#
+# Copyright (C) 2007 Red Hat, Inc.
+#
+# Distributed under the GNU Lesser General Public License v2.1 or later.
+# See COPYING for details
+#
+# David Lutterkort <dlutter@redhat.com>
+
+require '_libvirt'
+
+module Libvirt
+
+    # A version in Libvirt's representation
+    class Version
+        attr_reader :version, :type
+
+        def initialize(type, version)
+            @type = type
+            @version = version
+        end
+
+        def major
+            version / 1000000
+        end
+
+        def minor
+            version % 1000000 / 1000
+        end
+
+        def release
+            version % 1000
+        end
+
+        def to_s
+            "#{major}.#{minor}.#{release}"
+        end
+    end
+end