ruby-libvirt 0.1.0 → 0.2.0

data/ext/libvirt/domain.h

@@ -0,0 +1,8 @@
+#ifndef DOMAIN_H
+#define DOMAIN_H
+
+extern VALUE c_domain;
+
+void init_domain();
+
+#endif

data/ext/libvirt/extconf.rb

@@ -18,9 +18,38 @@ end
 
 libvirt_types = [ 'virNetworkPtr',
                   'virStoragePoolPtr',
-                  'virStorageVolPtr' ]
+                  'virStorageVolPtr',
+                  'virSecretPtr',
+                  'virNWFilterPtr',
+                  'virInterfacePtr',
+                  'virDomainBlockInfoPtr',
+                  'virDomainMemoryStatPtr',
+                  'virDomainSnapshotPtr',
+                  'virDomainJobInfoPtr',
+                ]
+
+libvirt_funcs = [ 'virStorageVolWipe',
+                  'virStoragePoolIsActive',
+                  'virStoragePoolIsPersistent',
+                  'virConnectGetLibVersion',
+                  'virConnectIsEncrypted',
+                  'virConnectIsSecure',
+                  'virNetworkIsActive',
+                  'virNetworkIsPersistent',
+                  'virNodeDeviceCreateXML',
+                  'virNodeDeviceDestroy',
+                  'virInterfaceIsActive',
+                  'virDomainMigrateToURI',
+                  'virDomainMigrateSetMaxDowntime',
+                  'virDomainManagedSave',
+                  'virDomainIsActive',
+                  'virDomainIsPersistent',
+                  'virConnectDomainXMLFromNative',
+                  'virConnectDomainXMLToNative',
+                ]
 
 have_libvirt_types(libvirt_types)
+have_libvirt_funcs(libvirt_funcs)
 
 create_header
 create_makefile(extension_name)

data/ext/libvirt/interface.c

@@ -0,0 +1,259 @@
+/*
+ * interface.c: virInterface methods
+ *
+ * Copyright (C) 2010 Red Hat Inc.
+ *
+ * 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_VIRINTERFACEPTR
+static VALUE c_interface;
+
+static void interface_free(void *i) {
+    generic_free(Interface, i);
+}
+
+static virInterfacePtr interface_get(VALUE s) {
+    generic_get(Interface, s);
+}
+
+static VALUE interface_new(virInterfacePtr i, VALUE conn) {
+    return generic_new(c_interface, i, conn, interface_free);
+}
+
+/*
+ * call-seq:
+ *   conn.num_of_interfaces -> fixnum
+ *
+ * Call +virConnectNumOfInterfaces+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfInterfaces]
+ */
+static VALUE libvirt_conn_num_of_interfaces(VALUE s) {
+    gen_conn_num_of(s, Interfaces);
+}
+
+/*
+ * call-seq:
+ *   conn.list_interfaces -> list
+ *
+ * Call +virConnectListInterfaces+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListInterfaces]
+ */
+static VALUE libvirt_conn_list_interfaces(VALUE s) {
+    gen_conn_list_names(s, Interfaces);
+}
+
+/*
+ * call-seq:
+ *   conn.num_of_defined_interfaces -> fixnum
+ *
+ * Call +virConnectNumOfDefinedInterfaces+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfDefinedInterfaces]
+ */
+static VALUE libvirt_conn_num_of_defined_interfaces(VALUE s) {
+    gen_conn_num_of(s, DefinedInterfaces);
+}
+
+/*
+ * call-seq:
+ *   conn.list_defined_interfaces -> list
+ *
+ * Call +virConnectListDefinedInterfaces+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListDefinedInterfaces]
+ */
+static VALUE libvirt_conn_list_defined_interfaces(VALUE s) {
+    gen_conn_list_names(s, DefinedInterfaces);
+}
+
+/*
+ * call-seq:
+ *   conn.lookup_interface_by_name -> Libvirt::Interface
+ *
+ * Call +virInterfaceLookupByName+[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceLookupByName]
+ */
+static VALUE libvirt_conn_lookup_interface_by_name(VALUE c, VALUE name) {
+    virInterfacePtr iface;
+    virConnectPtr conn = connect_get(c);
+
+    iface = virInterfaceLookupByName(conn, StringValueCStr(name));
+    _E(iface == NULL, create_error(e_RetrieveError, "virInterfaceLookupByName", "", conn));
+
+    return interface_new(iface, c);
+}
+
+/*
+ * call-seq:
+ *   conn.lookup_interface_by_mac -> Libvirt::Interface
+ *
+ * Call +virInterfaceLookupByMACString+[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceLookupByMACString]
+ */
+static VALUE libvirt_conn_lookup_interface_by_mac(VALUE c, VALUE mac) {
+    virInterfacePtr iface;
+    virConnectPtr conn = connect_get(c);
+
+    iface = virInterfaceLookupByMACString(conn, StringValueCStr(mac));
+    _E(iface == NULL, create_error(e_RetrieveError, "virInterfaceLookupByMACString", "", conn));
+
+    return interface_new(iface, c);
+}
+
+/*
+ * call-seq:
+ *   conn.define_interface_xml -> Libvirt::Interface
+ *
+ * Call +virInterfaceDefineXML+[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceDefineXML]
+ */
+static VALUE libvirt_conn_define_interface_xml(int argc, VALUE *argv, VALUE c) {
+    virInterfacePtr iface;
+    virConnectPtr conn = connect_get(c);
+    VALUE xml, flags;
+
+    rb_scan_args(argc, argv, "11", &xml, &flags);
+
+    if (NIL_P(flags))
+        flags = INT2FIX(0);
+
+    iface = virInterfaceDefineXML(conn, StringValueCStr(xml), NUM2UINT(flags));
+    _E(iface == NULL, create_error(e_DefinitionError, "virInterfaceDefineXML", "", conn));
+
+    return interface_new(iface, c);
+}
+
+/*
+ * call-seq:
+ *   interface.undefine -> nil
+ *
+ * Call +virInterfaceUndefine+[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceUndefine]
+ */
+static VALUE libvirt_interface_undefine(VALUE s) {
+    gen_call_void(virInterfaceUndefine, conn(s), interface_get(s));
+}
+
+/*
+ * call-seq:
+ *   interface.create -> nil
+ *
+ * Call +virInterfaceCreate+[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceCreate]
+ */
+static VALUE libvirt_interface_create(VALUE s) {
+    gen_call_void(virInterfaceCreate, conn(s), interface_get(s), 0);
+}
+
+/*
+ * call-seq:
+ *   interface.destroy -> nil
+ *
+ * Call +virInterfaceDestroy+[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceDestroy]
+ */
+static VALUE libvirt_interface_destroy(VALUE s) {
+    gen_call_void(virInterfaceDestroy, conn(s), interface_get(s), 0);
+}
+
+#if HAVE_VIRINTERFACEISACTIVE
+/*
+ * call-seq:
+ *   interface.active? -> [true|false]
+ *
+ * Call +virInterfaceIsActive+[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceIsActive]
+ */
+static VALUE libvirt_interface_active_p(VALUE p) {
+    gen_call_truefalse(virInterfaceIsActive, conn(p), interface_get(p));
+}
+#endif
+
+/*
+ * call-seq:
+ *   interface.name -> string
+ *
+ * Call +virInterfaceGetName+[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceGetName]
+ */
+static VALUE libvirt_interface_name(VALUE s) {
+    gen_call_string(virInterfaceGetName, conn(s), 0, interface_get(s));
+}
+
+/*
+ * call-seq:
+ *   interface.mac -> string
+ *
+ * Call +virInterfaceGetMACString+[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceGetMACString]
+ */
+static VALUE libvirt_interface_mac(VALUE s) {
+    gen_call_string(virInterfaceGetMACString, conn(s), 0, interface_get(s));
+}
+
+/*
+ * call-seq:
+ *   interface.xml_desc -> string
+ *
+ * Call +virInterfaceGetXMLDesc+[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceGetXMLDesc]
+ */
+static VALUE libvirt_interface_xml_desc(int argc, VALUE *argv, VALUE s) {
+    VALUE flags;
+
+    rb_scan_args(argc, argv, "01", &flags);
+
+    if (NIL_P(flags))
+        flags = INT2FIX(0);
+
+    gen_call_string(virInterfaceGetXMLDesc, conn(s), 1, interface_get(s),
+                    NUM2UINT(flags));
+}
+
+#endif
+
+/*
+ * Class Libvirt::Interface
+ */
+void init_interface()
+{
+#if HAVE_TYPE_VIRINTERFACEPTR
+    c_interface = rb_define_class_under(m_libvirt, "Interface", rb_cObject);
+#ifdef VIR_INTERFACE_XML_INACTIVE
+    rb_define_const(c_interface, "XML_INACTIVE",
+                    INT2NUM(VIR_INTERFACE_XML_INACTIVE));
+#endif
+    rb_define_attr(c_interface, "connection", 1, 0);
+
+    /* Interface lookup/creation methods */
+    rb_define_method(c_connect, "num_of_interfaces",
+                     libvirt_conn_num_of_interfaces, 0);
+    rb_define_method(c_connect, "list_interfaces",
+                     libvirt_conn_list_interfaces, 0);
+    rb_define_method(c_connect, "num_of_defined_interfaces",
+                     libvirt_conn_num_of_defined_interfaces, 0);
+    rb_define_method(c_connect, "list_defined_interfaces",
+                     libvirt_conn_list_defined_interfaces, 0);
+    rb_define_method(c_connect, "lookup_interface_by_name",
+                     libvirt_conn_lookup_interface_by_name, 1);
+    rb_define_method(c_connect, "lookup_interface_by_mac",
+                     libvirt_conn_lookup_interface_by_mac, 1);
+    rb_define_method(c_connect, "define_interface_xml",
+                     libvirt_conn_define_interface_xml, -1);
+
+    /* Interface object methods */
+    rb_define_method(c_interface, "name", libvirt_interface_name, 0);
+    rb_define_method(c_interface, "mac", libvirt_interface_mac, 0);
+    rb_define_method(c_interface, "xml_desc", libvirt_interface_xml_desc, -1);
+    rb_define_method(c_interface, "undefine", libvirt_interface_undefine, 0);
+    rb_define_method(c_interface, "create", libvirt_interface_create, -1);
+    rb_define_method(c_interface, "destroy", libvirt_interface_destroy, -1);
+#if HAVE_VIRINTERFACEISACTIVE
+    rb_define_method(c_interface, "active?", libvirt_interface_active_p, 0);
+#endif
+#endif
+}

data/ext/libvirt/interface.h

@@ -0,0 +1,6 @@
+#ifndef INTERFACE_H
+#define INTERFACE_H
+
+void init_interface();
+
+#endif

data/ext/libvirt/network.c

@@ -0,0 +1,338 @@
+/*
+ * network.c: virNetwork methods
+ *
+ * Copyright (C) 2007,2010 Red Hat Inc.
+ *
+ * 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_VIRNETWORKPTR
+static VALUE c_network;
+
+static void network_free(void *d) {
+    generic_free(Network, d);
+}
+
+static virNetworkPtr network_get(VALUE s) {
+    generic_get(Network, s);
+}
+
+static VALUE network_new(virNetworkPtr n, VALUE conn) {
+    return generic_new(c_network, n, conn, network_free);
+}
+
+/*
+ * call-seq:
+ *   conn.num_of_networks -> fixnum
+ *
+ * Call +virConnectNumOfNetworks+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfNetworks]
+ */
+static VALUE libvirt_conn_num_of_networks(VALUE s) {
+    gen_conn_num_of(s, Networks);
+}
+
+/*
+ * call-seq:
+ *   conn.list_networks -> list
+ *
+ * Call +virConnectListNetworks+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListNetworks]
+ */
+static VALUE libvirt_conn_list_networks(VALUE s) {
+    gen_conn_list_names(s, Networks);
+}
+
+/*
+ * call-seq:
+ *   conn.num_of_defined_networks -> fixnum
+ *
+ * Call +virConnectNumOfDefinedNetworks+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfDefinedNetworks]
+ */
+static VALUE libvirt_conn_num_of_defined_networks(VALUE s) {
+    gen_conn_num_of(s, DefinedNetworks);
+}
+
+/*
+ * call-seq:
+ *   conn.list_of_defined_networks -> list
+ *
+ * Call +virConnectListDefinedNetworks+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListDefinedNetworks]
+ */
+static VALUE libvirt_conn_list_defined_networks(VALUE s) {
+    gen_conn_list_names(s, DefinedNetworks);
+}
+
+/*
+ * call-seq:
+ *   conn.lookup_network_by_name -> Libvirt::Network
+ *
+ * Call +virNetworkLookupByName+[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkLookupByName]
+ */
+static VALUE libvirt_conn_lookup_network_by_name(VALUE c, VALUE name) {
+    virNetworkPtr netw;
+    virConnectPtr conn = connect_get(c);
+
+    netw = virNetworkLookupByName(conn, StringValueCStr(name));
+    _E(netw == NULL, create_error(e_RetrieveError, "virNetworkLookupByName", "", conn));
+
+    return network_new(netw, c);
+}
+
+/*
+ * call-seq:
+ *   conn.lookup_network_by_uuid -> Libvirt::Network
+ *
+ * Call +virNetworkLookupByUUIDString+[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkLookupByUUIDString]
+ */
+static VALUE libvirt_conn_lookup_network_by_uuid(VALUE c, VALUE uuid) {
+    virNetworkPtr netw;
+    virConnectPtr conn = connect_get(c);
+
+    netw = virNetworkLookupByUUIDString(conn, StringValueCStr(uuid));
+    _E(netw == NULL, create_error(e_RetrieveError, "virNetworkLookupByUUID", "", conn));
+
+    return network_new(netw, c);
+}
+
+/*
+ * call-seq:
+ *   conn.create_network_xml -> Libvirt::Network
+ *
+ * Call +virNetworkCreateXML+[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkCreateXML]
+ */
+static VALUE libvirt_conn_create_network_xml(VALUE c, VALUE xml) {
+    virNetworkPtr netw;
+    virConnectPtr conn = connect_get(c);
+
+    netw = virNetworkCreateXML(conn, StringValueCStr(xml));
+    _E(netw == NULL, create_error(e_Error, "virNetworkCreateXML", "", conn));
+
+    return network_new(netw, c);
+}
+
+/*
+ * call-seq:
+ *   conn.define_network_xml -> Libvirt::Network
+ *
+ * Call +virNetworkDefineXML+[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkDefineXML]
+ */
+static VALUE libvirt_conn_define_network_xml(VALUE c, VALUE xml) {
+    virNetworkPtr netw;
+    virConnectPtr conn = connect_get(c);
+
+    netw = virNetworkDefineXML(conn, StringValueCStr(xml));
+    _E(netw == NULL, create_error(e_DefinitionError, "virNetworkDefineXML", "", conn));
+
+    return network_new(netw, c);
+}
+
+/*
+ * call-seq:
+ *   net.undefine -> nil
+ *
+ * Call +virNetworkUndefine+[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkUndefine]
+ */
+static VALUE libvirt_netw_undefine(VALUE s) {
+    gen_call_void(virNetworkUndefine, conn(s), network_get(s));
+}
+
+/*
+ * call-seq:
+ *   net.create -> nil
+ *
+ * Call +virNetworkCreate+[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkCreate]
+ */
+static VALUE libvirt_netw_create(VALUE s) {
+    gen_call_void(virNetworkCreate, conn(s), network_get(s));
+}
+
+/*
+ * call-seq:
+ *   net.destroy -> nil
+ *
+ * Call +virNetworkDestroy+[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkDestroy]
+ */
+static VALUE libvirt_netw_destroy(VALUE s) {
+    gen_call_void(virNetworkDestroy, conn(s), network_get(s));
+}
+
+/*
+ * call-seq:
+ *   net.name -> string
+ *
+ * Call +virNetworkGetName+[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkGetName]
+ */
+static VALUE libvirt_netw_name(VALUE s) {
+    gen_call_string(virNetworkGetName, conn(s), 0, network_get(s));
+}
+
+/*
+ * call-seq:
+ *   net.uuid -> string
+ *
+ * Call +virNetworkGetUUIDString+[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkGetUUIDString]
+ */
+static VALUE libvirt_netw_uuid(VALUE s) {
+    virNetworkPtr netw = network_get(s);
+    char uuid[VIR_UUID_STRING_BUFLEN];
+    int r;
+
+    r = virNetworkGetUUIDString(netw, uuid);
+    _E(r < 0, create_error(e_RetrieveError, "virNetworkGetUUIDString", "", conn(s)));
+
+    return rb_str_new2((char *) uuid);
+}
+
+/*
+ * call-seq:
+ *   net.xml_desc -> string
+ *
+ * Call +virNetworkGetXMLDesc+[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkGetXMLDesc]
+ */
+static VALUE libvirt_netw_xml_desc(int argc, VALUE *argv, VALUE s) {
+    VALUE flags;
+
+    rb_scan_args(argc, argv, "01", &flags);
+
+    if (NIL_P(flags))
+        flags = INT2FIX(0);
+
+    gen_call_string(virNetworkGetXMLDesc, conn(s), 1, network_get(s),
+                    NUM2UINT(flags));
+}
+
+/*
+ * call-seq:
+ *   net.bridge_name -> string
+ *
+ * Call +virNetworkGetBridgeName+[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkGetBridgeName]
+ */
+static VALUE libvirt_netw_bridge_name(VALUE s) {
+    gen_call_string(virNetworkGetBridgeName, conn(s), 1, network_get(s));
+}
+
+/*
+ * call-seq:
+ *   net.autostart? -> [true|false]
+ *
+ * Call +virNetworkGetAutostart+[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkGetAutostart]
+ */
+static VALUE libvirt_netw_autostart(VALUE s){
+    virNetworkPtr netw = network_get(s);
+    int r, autostart;
+
+    r = virNetworkGetAutostart(netw, &autostart);
+    _E(r < 0, create_error(e_RetrieveError, "virNetworkAutostart", "", conn(s)));
+
+    return autostart ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *   net.autostart_set -> nil
+ *
+ * Call +virNetworkSetAutostart+[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkSetAutostart]
+ */
+static VALUE libvirt_netw_autostart_set(VALUE s, VALUE autostart) {
+    gen_call_void(virNetworkSetAutostart, conn(s), network_get(s),
+                  RTEST(autostart) ? 1 : 0);
+}
+
+/*
+ * call-seq:
+ *   net.free -> nil
+ *
+ * Call +virNetworkFree+[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkFree]
+ */
+static VALUE libvirt_netw_free(VALUE s) {
+    gen_call_free(Network, s);
+}
+
+#if HAVE_VIRNETWORKISACTIVE
+/*
+ * call-seq:
+ *   net.active? -> [true|false]
+ *
+ * Call +virNetworkIsActive+[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkIsActive]
+ */
+static VALUE libvirt_netw_active_p(VALUE s) {
+    gen_call_truefalse(virNetworkIsActive, conn(s), network_get(s));
+}
+#endif
+
+#if HAVE_VIRNETWORKISPERSISTENT
+/*
+ * call-seq:
+ *   net.persistent? -> [true|false]
+ *
+ * Call +virNetworkIsPersistent+[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkIsPersistent]
+ */
+static VALUE libvirt_netw_persistent_p(VALUE s) {
+    gen_call_truefalse(virNetworkIsPersistent, conn(s), network_get(s));
+}
+#endif
+
+#endif
+
+/*
+ * Class Libvirt::Network
+ */
+void init_network()
+{
+#if HAVE_TYPE_VIRNETWORKPTR
+    c_network = rb_define_class_under(m_libvirt, "Network", rb_cObject);
+    rb_define_attr(c_network, "connection", 1, 0);
+
+    rb_define_method(c_connect, "num_of_networks",
+                     libvirt_conn_num_of_networks, 0);
+    rb_define_method(c_connect, "list_networks", libvirt_conn_list_networks, 0);
+    rb_define_method(c_connect, "num_of_defined_networks",
+                     libvirt_conn_num_of_defined_networks, 0);
+    rb_define_method(c_connect, "list_defined_networks",
+                     libvirt_conn_list_defined_networks, 0);
+    rb_define_method(c_connect, "lookup_network_by_name",
+                     libvirt_conn_lookup_network_by_name, 1);
+    rb_define_method(c_connect, "lookup_network_by_uuid",
+                     libvirt_conn_lookup_network_by_uuid, 1);
+    rb_define_method(c_connect, "create_network_xml",
+                     libvirt_conn_create_network_xml, 1);
+    rb_define_method(c_connect, "define_network_xml",
+                     libvirt_conn_define_network_xml, 1);
+
+    rb_define_method(c_network, "undefine", libvirt_netw_undefine, 0);
+    rb_define_method(c_network, "create", libvirt_netw_create, 0);
+    rb_define_method(c_network, "destroy", libvirt_netw_destroy, 0);
+    rb_define_method(c_network, "name", libvirt_netw_name, 0);
+    rb_define_method(c_network, "uuid", libvirt_netw_uuid, 0);
+    rb_define_method(c_network, "xml_desc", libvirt_netw_xml_desc, -1);
+    rb_define_method(c_network, "bridge_name", libvirt_netw_bridge_name, 0);
+    rb_define_method(c_network, "autostart", libvirt_netw_autostart, 0);
+    rb_define_method(c_network, "autostart?", libvirt_netw_autostart, 0);
+    rb_define_method(c_network, "autostart=", libvirt_netw_autostart_set, 1);
+    rb_define_method(c_network, "free", libvirt_netw_free, 0);
+#if HAVE_VIRNETWORKISACTIVE
+    rb_define_method(c_network, "active?", libvirt_netw_active_p, 0);
+#endif
+#if HAVE_VIRNETWORKISPERSISTENT
+    rb_define_method(c_network, "persistent?", libvirt_netw_persistent_p, 0);
+#endif
+#endif
+}