class Libvirt::Connect

Constants

CPU_COMPARE_ERROR
CPU_COMPARE_IDENTICAL
CPU_COMPARE_INCOMPATIBLE
CPU_COMPARE_SUPERSET
DOMAIN_EVENT_DEFINED
DOMAIN_EVENT_DEFINED_ADDED
DOMAIN_EVENT_DEFINED_UPDATED
DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV4
DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV6
DOMAIN_EVENT_GRAPHICS_CONNECT
DOMAIN_EVENT_GRAPHICS_DISCONNECT
DOMAIN_EVENT_GRAPHICS_INITIALIZE
DOMAIN_EVENT_ID_CONTROL_ERROR
DOMAIN_EVENT_ID_GRAPHICS
DOMAIN_EVENT_ID_IO_ERROR
DOMAIN_EVENT_ID_IO_ERROR_REASON
DOMAIN_EVENT_ID_LIFECYCLE
DOMAIN_EVENT_ID_REBOOT
DOMAIN_EVENT_ID_RTC_CHANGE
DOMAIN_EVENT_ID_WATCHDOG
DOMAIN_EVENT_IO_ERROR_NONE
DOMAIN_EVENT_IO_ERROR_PAUSE
DOMAIN_EVENT_IO_ERROR_REPORT
DOMAIN_EVENT_RESUMED
DOMAIN_EVENT_RESUMED_MIGRATED
DOMAIN_EVENT_RESUMED_UNPAUSED
DOMAIN_EVENT_STARTED
DOMAIN_EVENT_STARTED_BOOTED
DOMAIN_EVENT_STARTED_FROM_SNAPSHOT
DOMAIN_EVENT_STARTED_MIGRATED
DOMAIN_EVENT_STARTED_RESTORED
DOMAIN_EVENT_STOPPED
DOMAIN_EVENT_STOPPED_CRASHED
DOMAIN_EVENT_STOPPED_DESTROYED
DOMAIN_EVENT_STOPPED_FAILED
DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT
DOMAIN_EVENT_STOPPED_MIGRATED
DOMAIN_EVENT_STOPPED_SAVED
DOMAIN_EVENT_STOPPED_SHUTDOWN
DOMAIN_EVENT_SUSPENDED
DOMAIN_EVENT_SUSPENDED_IOERROR
DOMAIN_EVENT_SUSPENDED_MIGRATED
DOMAIN_EVENT_SUSPENDED_PAUSED
DOMAIN_EVENT_SUSPENDED_WATCHDOG
DOMAIN_EVENT_UNDEFINED
DOMAIN_EVENT_UNDEFINED_REMOVED
DOMAIN_EVENT_WATCHDOG_DEBUG
DOMAIN_EVENT_WATCHDOG_NONE
DOMAIN_EVENT_WATCHDOG_PAUSE
DOMAIN_EVENT_WATCHDOG_POWEROFF
DOMAIN_EVENT_WATCHDOG_RESET
DOMAIN_EVENT_WATCHDOG_SHUTDOWN

Public Instance Methods

baseline_cpu([xml, xml2, ...], flags=0) → XML click to toggle source

Call virConnectBaselineCPU[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectBaselineCPU] to compare the most feature-rich CPU which is compatible with all given host CPUs.

static VALUE libvirt_conn_baseline_cpu(int argc, VALUE *argv, VALUE s) {
    VALUE xmlcpus, flags_val;
    virConnectPtr conn = connect_get(s);
    char *r;
    VALUE retval;
    unsigned int ncpus, flags;
    VALUE entry;
    const char **xmllist;
    int i;
    int exception = 0;
    struct rb_ary_entry_arg arg;

    rb_scan_args(argc, argv, "11", &xmlcpus, &flags_val);
    /*
     * We check flags up-front here so that we get a TypeError early on if
     * flags is bogus.
     */
    if (NIL_P(flags_val))
        flags = 0;
    else
        flags = NUM2UINT(flags_val);

    Check_Type(xmlcpus, T_ARRAY);

    if (RARRAY_LEN(xmlcpus) < 1)
        rb_raise(rb_eArgError, "wrong number of cpu arguments (%d for 1 or more)",
                 RARRAY_LEN(xmlcpus));

    ncpus = RARRAY_LEN(xmlcpus);
    xmllist = ALLOC_N(const char *, ncpus);

    for (i = 0; i < ncpus; i++) {
        arg.arr = xmlcpus;
        arg.elem = i;
        entry = rb_protect(rb_ary_entry_wrap, (VALUE)&arg, &exception);
        if (exception) {
            xfree(xmllist);
            rb_jump_tag(exception);
        }

        xmllist[i] = (char *)rb_protect(rb_string_value_cstr_wrap,
                                        (VALUE)&entry, &exception);
        if (exception) {
            xfree(xmllist);
            rb_jump_tag(exception);
        }
    }

    r = virConnectBaselineCPU(conn, xmllist, ncpus, flags);
    xfree(xmllist);
    _E(r == NULL, create_error(e_RetrieveError, "virConnectBaselineCPU", conn));

    retval = rb_protect(rb_str_new2_wrap, (VALUE)&r, &exception);
    if (exception) {
        free(r);
        rb_jump_tag(exception);
    }

    free(r);

    return retval;
}
capabilities → string click to toggle source

Call virConnectGetCapabilities[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetCapabilities] to retrieve the capabilities XML for this connection.

static VALUE libvirt_conn_capabilities(VALUE s) {
    gen_call_string(virConnectGetCapabilities, conn(s), 1, connect_get(s));
}
close → nil click to toggle source

Call virConnectClose[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectClose] to close the connection.

static VALUE libvirt_conn_close(VALUE s) {
    virConnectPtr conn;
    Data_Get_Struct(s, virConnect, conn);
    if (conn) {
        connect_close(conn);
        DATA_PTR(s) = NULL;
    }
    return Qnil;
}
closed? → [True|False] click to toggle source

Return true if the connection is closed, false if it is open.

static VALUE libvirt_conn_closed_p(VALUE s) {
    virConnectPtr conn;

    Data_Get_Struct(s, virConnect, conn);
    return (conn==NULL) ? Qtrue : Qfalse;
}
compare_cpu(xml, flags=0) → compareflag click to toggle source

Call virConnectCompareCPU[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectCompareCPU] to compare the host CPU with the XML contained in xml. Returns one of Libvirt::CPU_COMPARE_ERROR, Libvirt::CPU_COMPARE_INCOMPATIBLE, Libvirt::CPU_COMPARE_IDENTICAL, or Libvirt::CPU_COMPARE_SUPERSET.

static VALUE libvirt_conn_compare_cpu(int argc, VALUE *argv, VALUE s) {
    VALUE xml, flags;

    rb_scan_args(argc, argv, "11", &xml, &flags);
    if (NIL_P(flags))
        flags = INT2NUM(0);

    gen_call_int(virConnectCompareCPU, conn(s), connect_get(s),
                 StringValueCStr(xml), NUM2UINT(flags));
}
create_domain_linux(xml, flags=0) → Libvirt::Domain click to toggle source

Call virDomainCreateLinux[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainCreateLinux] to start a transient domain from the given XML. Deprecated; use conn.create_domain_xml instead.

static VALUE libvirt_conn_create_linux(int argc, VALUE *argv, VALUE c) {
    virDomainPtr dom;
    virConnectPtr conn = connect_get(c);
    VALUE flags, xml;

    rb_scan_args(argc, argv, "11", &xml, &flags);

    if (NIL_P(flags))
        flags = INT2NUM(0);

    dom = virDomainCreateLinux(conn, StringValueCStr(xml), NUM2UINT(flags));
    _E(dom == NULL, create_error(e_Error, "virDomainCreateLinux", conn));

    return domain_new(dom, c);
}
create_domain_xml(xml, flags=0) → Libvirt::Domain click to toggle source

Call virDomainCreateXML[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainCreateXML] to start a transient domain from the given XML.

static VALUE libvirt_conn_create_xml(int argc, VALUE *argv, VALUE c) {
    virDomainPtr dom;
    virConnectPtr conn = connect_get(c);
    VALUE flags, xml;

    rb_scan_args(argc, argv, "11", &xml, &flags);

    if (NIL_P(flags))
        flags = INT2NUM(0);

    dom = virDomainCreateXML(conn, StringValueCStr(xml), NUM2UINT(flags));
    _E(dom == NULL, create_error(e_Error, "virDomainCreateXML", conn));

    return domain_new(dom, c);
}
create_network_xml(xml) → Libvirt::Network click to toggle source

Call virNetworkCreateXML[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkCreateXML] to start a new transient network from xml.

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);
}
create_nodedevice_xml(xml, flags=0) → Libvirt::NodeDevice click to toggle source

Call virNodeDeviceCreateXML[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeDeviceCreateXML] to create a new node device from xml.

static VALUE libvirt_conn_create_nodedevice_xml(int argc, VALUE *argv,
                                                VALUE c) {
    virNodeDevicePtr nodedev;
    virConnectPtr conn = connect_get(c);
    VALUE xml, flags;

    rb_scan_args(argc, argv, "11", &xml, &flags);

    if (NIL_P(flags))
        flags = INT2NUM(0);

    nodedev = virNodeDeviceCreateXML(conn, StringValueCStr(xml),
                                     NUM2UINT(flags));
    _E(nodedev == NULL, create_error(e_Error, "virNodeDeviceCreateXML", conn));

    return nodedevice_new(nodedev, c);
}
create_storage_pool_xml(xml, flags=0) → Libvirt::StoragePool click to toggle source

Call virStoragePoolCreateXML[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolCreateXML] to start a new transient storage pool from xml.

static VALUE libvirt_conn_create_pool_xml(int argc, VALUE *argv, VALUE c) {
    virStoragePoolPtr pool;
    virConnectPtr conn = connect_get(c);
    VALUE xml, flags;

    rb_scan_args(argc, argv, "11", &xml, &flags);

    if (NIL_P(flags))
        flags = INT2NUM(0);

    pool = virStoragePoolCreateXML(conn, StringValueCStr(xml), NUM2UINT(flags));
    _E(pool == NULL, create_error(e_Error, "virStoragePoolCreateXML", conn));

    return pool_new(pool, c);
}
define_domain_xml(xml) → Libvirt::Domain click to toggle source

Call virDomainDefineXML[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainDefineXML] to define a permanent domain on this connection.

static VALUE libvirt_conn_define_domain_xml(VALUE c, VALUE xml) {
    virDomainPtr dom;
    virConnectPtr conn = connect_get(c);

    dom = virDomainDefineXML(conn, StringValueCStr(xml));
    _E(dom == NULL, create_error(e_DefinitionError, "virDomainDefineXML",
                                 conn));

    return domain_new(dom, c);
}
define_interface_xml(xml, flags=0) → Libvirt::Interface click to toggle source

Call virInterfaceDefineXML[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceDefineXML] to define a new interface from xml.

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 = INT2NUM(0);

    iface = virInterfaceDefineXML(conn, StringValueCStr(xml), NUM2UINT(flags));
    _E(iface == NULL, create_error(e_DefinitionError, "virInterfaceDefineXML",
                                   conn));

    return interface_new(iface, c);
}
define_network_xml(xml) → Libvirt::Network click to toggle source

Call virNetworkDefineXML[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkDefineXML] to define a new permanent network from xml.

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);
}
define_nwfilter_xml(xml) → Libvirt::NWFilter click to toggle source

Call virNWFilterDefineXML[http://www.libvirt.org/html/libvirt-libvirt.html#virNWFilterDefineXML] to define a new network filter from xml.

static VALUE libvirt_conn_define_nwfilter_xml(VALUE c, VALUE xml) {
    virNWFilterPtr nwfilter;
    virConnectPtr conn = connect_get(c);

    nwfilter = virNWFilterDefineXML(conn, StringValueCStr(xml));
    _E(nwfilter == NULL, create_error(e_DefinitionError, "virNWFilterDefineXML",
                                      conn));

    return nwfilter_new(nwfilter, c);
}
define_secret_xml(xml, flags=0) → Libvirt::Secret click to toggle source

Call virSecretDefineXML[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretDefineXML] to define a new secret from xml.

static VALUE libvirt_conn_define_secret_xml(int argc, VALUE *argv, VALUE c) {
    virSecretPtr secret;
    virConnectPtr conn = connect_get(c);
    VALUE xml, flags;

    rb_scan_args(argc, argv, "11", &xml, &flags);

    if (NIL_P(flags))
        flags = INT2NUM(0);

    secret = virSecretDefineXML(conn, StringValueCStr(xml), NUM2UINT(flags));
    _E(secret == NULL, create_error(e_DefinitionError, "virSecretDefineXML",
                                    conn));

    return secret_new(secret, c);
}
define_storage_pool_xml(xml, flags=0) → Libvirt::StoragePool click to toggle source

Call virStoragePoolDefineXML[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolDefineXML] to define a permanent storage pool from xml.

static VALUE libvirt_conn_define_pool_xml(int argc, VALUE *argv, VALUE c) {
    virStoragePoolPtr pool;
    virConnectPtr conn = connect_get(c);
    VALUE xml, flags;

    rb_scan_args(argc, argv, "11", &xml, &flags);

    if (NIL_P(flags))
        flags = INT2NUM(0);

    pool = virStoragePoolDefineXML(conn, StringValueCStr(xml), NUM2UINT(flags));
    _E(pool == NULL, create_error(e_DefinitionError, "virStoragePoolDefineXML",
                                  conn));

    return pool_new(pool, c);
}
discover_storage_pool_sources(type, srcSpec=nil, flags=0) → string click to toggle source

Call virConnectFindStoragePoolSources[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectFindStoragePoolSources] to find the storage pool sources corresponding to type.

static VALUE libvirt_conn_find_storage_pool_sources(int argc, VALUE *argv,
                                                    VALUE c) {
    VALUE type, srcSpec_val, flags;

    rb_scan_args(argc, argv, "12", &type, &srcSpec_val, &flags);

    if (NIL_P(flags))
        flags = INT2NUM(0);

    gen_call_string(virConnectFindStoragePoolSources, conn(c), 1,
                    connect_get(c), StringValueCStr(type),
                    get_string_or_nil(srcSpec_val), NUM2UINT(flags));
}
domain_event_deregister(callback) → nil click to toggle source

Call virConnectDomainEventDeregister[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectDomainEventDeregister] to deregister the event callback from libvirt. This method is deprecated in favor of #domain_event_deregister_any (though they cannot be mixed; if the callback was registered with #domain_event_register, it must be deregistered with #domain_event_deregister).

static VALUE libvirt_conn_domain_event_deregister(VALUE c) {
    gen_call_void(virConnectDomainEventDeregister, conn(c), connect_get(c),
                  domain_event_callback);
}
domain_event_deregister_any(callbackID) → nil click to toggle source

Call virConnectDomainEventDeregisterAny[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectDomainEventDeregisterAny] to deregister a callback from libvirt. The callbackID must be a libvirt-specific handle returned by domain_event_register_any.

static VALUE libvirt_conn_domain_event_deregister_any(VALUE c,
                                                      VALUE callbackID) {
    gen_call_void(virConnectDomainEventDeregisterAny, conn(c), connect_get(c),
                  NUM2INT(callbackID));
}
domain_event_register(callback, opaque=nil) → nil click to toggle source

Call virConnectDomainEventRegister[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectDomainEventRegister] to register callback for domain lifecycle events with libvirt. The callback can either be a Symbol (that is the name of a method to callback) or a Proc. The callback must accept 5 parameters: Libvirt::Connect, Libvirt::Domain, event, detail, opaque. The opaque parameter to #domain_event_register can be any valid ruby type, and will be passed into callback as “opaque”. This method is deprecated in favor of domain_event_register_any.

static VALUE libvirt_conn_domain_event_register(int argc, VALUE *argv,
                                                VALUE c) {
    VALUE cb, opaque;
    VALUE passthrough;

    rb_scan_args(argc, argv, "11", &cb, &opaque);

    if (!is_symbol_or_proc(cb))
        rb_raise(rb_eTypeError, "wrong argument type (expected Symbol or Proc)");

    passthrough = rb_ary_new();
    rb_ary_store(passthrough, 0, cb);
    rb_ary_store(passthrough, 1, opaque);

    gen_call_void(virConnectDomainEventRegister, conn(c), connect_get(c),
                  domain_event_callback, (void *)passthrough, NULL);
}
domain_event_register_any(eventID, callback, dom=nil, opaque=nil) → fixnum click to toggle source

Call virConnectDomainEventRegisterAny[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectDomainEventRegisterAny] to register callback for eventID with libvirt. The eventID must be one of the Libvirt::Connect::DOMAIN_EVENT_ID_* constants. The callback can either be a Symbol (that is the name of a method to callback) or a Proc. Note that the callback must accept different numbers of arguments depending on the eventID passed in. The arguments are as follows:

If dom is a valid Libvirt::Domain object, then only events from that domain will be seen. The opaque parameter can be any valid ruby type, and will be passed into callback as “opaque”. This method returns a libvirt-specific handle, which must be used by the application to deregister the callback later (see #domain_event_deregister_any).

static VALUE libvirt_conn_domain_event_register_any(int argc, VALUE *argv,
                                                    VALUE c) {
    VALUE eventID, cb, dom, opaque;
    virDomainPtr domain;
    virConnectDomainEventGenericCallback internalcb = NULL;
    VALUE passthrough;

    rb_scan_args(argc, argv, "22", &eventID, &cb, &dom, &opaque);

    if (!is_symbol_or_proc(cb))
        rb_raise(rb_eTypeError, "wrong argument type (expected Symbol or Proc)");

    if (NIL_P(dom))
        domain = NULL;
    else
        domain = domain_get(dom);

    switch(NUM2INT(eventID)) {
    case VIR_DOMAIN_EVENT_ID_LIFECYCLE:
        internalcb = VIR_DOMAIN_EVENT_CALLBACK(domain_event_lifecycle_callback);
        break;
    case VIR_DOMAIN_EVENT_ID_REBOOT:
        internalcb = VIR_DOMAIN_EVENT_CALLBACK(domain_event_reboot_callback);
        break;
    case VIR_DOMAIN_EVENT_ID_RTC_CHANGE:
        internalcb = VIR_DOMAIN_EVENT_CALLBACK(domain_event_rtc_callback);
        break;
    case VIR_DOMAIN_EVENT_ID_WATCHDOG:
        internalcb = VIR_DOMAIN_EVENT_CALLBACK(domain_event_watchdog_callback);
        break;
    case VIR_DOMAIN_EVENT_ID_IO_ERROR:
        internalcb = VIR_DOMAIN_EVENT_CALLBACK(domain_event_io_error_callback);
        break;
    case VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON:
        internalcb = VIR_DOMAIN_EVENT_CALLBACK(domain_event_io_error_reason_callback);
        break;
    case VIR_DOMAIN_EVENT_ID_GRAPHICS:
        internalcb = VIR_DOMAIN_EVENT_CALLBACK(domain_event_graphics_callback);
        break;
    default:
        rb_raise(rb_eArgError, "invalid eventID argument %d",
                 NUM2INT(eventID));
        break;
    }

    passthrough = rb_ary_new();
    rb_ary_store(passthrough, 0, cb);
    rb_ary_store(passthrough, 1, opaque);

    gen_call_int(virConnectDomainEventRegisterAny, conn(c), connect_get(c),
                 domain, NUM2INT(eventID), internalcb, (void *)passthrough,
                 NULL);
}
domain_xml_from_native(nativeFormat, xml, flags=0) → string click to toggle source

Call virConnectDomainXMLFromNative[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectDomainXMLFromNative] to convert a native hypervisor domain representation to libvirt XML.

static VALUE libvirt_conn_domain_xml_from_native(int argc, VALUE *argv,
                                                 VALUE s) {
    VALUE nativeFormat, xml, flags;
    char *ret;
    VALUE result;

    rb_scan_args(argc, argv, "21", &nativeFormat, &xml, &flags);

    if (NIL_P(flags))
        flags = INT2NUM(0);

    ret = virConnectDomainXMLFromNative(conn(s), StringValueCStr(nativeFormat),
                                        StringValueCStr(xml), NUM2UINT(flags));
    _E(ret == NULL, create_error(e_Error, "virConnectDomainXMLFromNative",
                                 conn(s)));

    result = rb_str_new2(ret);

    free(ret);

    return result;
}
domain_xml_to_native(nativeFormat, xml, flags=0) → string click to toggle source

Call virConnectDomainXMLToNative[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectDomainXMLToNative] to convert libvirt XML to a native domain hypervisor representation.

static VALUE libvirt_conn_domain_xml_to_native(int argc, VALUE *argv, VALUE s) {
    VALUE nativeFormat, xml, flags;
    char *ret;
    VALUE result;

    rb_scan_args(argc, argv, "21", &nativeFormat, &xml, &flags);

    if (NIL_P(flags))
        flags = INT2NUM(0);

    ret = virConnectDomainXMLToNative(conn(s), StringValueCStr(nativeFormat),
                                      StringValueCStr(xml), NUM2UINT(flags));
    _E(ret == NULL, create_error(e_Error, "virConnectDomainXMLToNative",
                                 conn(s)));

    result = rb_str_new2(ret);

    free(ret);

    return result;
}
encrypted? → [True|False] click to toggle source

Call virConnectIsEncrypted[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectIsEncrypted] to determine if the connection is encrypted.

static VALUE libvirt_conn_encrypted_p(VALUE s) {
    gen_call_truefalse(virConnectIsEncrypted, conn(s), connect_get(s));
}
hostname → string click to toggle source

Call virConnectGetHostname[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetHostname] to retrieve the hostname of the hypervisor for this connection.

static VALUE libvirt_conn_hostname(VALUE s) {
    gen_call_string(virConnectGetHostname, conn(s), 1, connect_get(s));
}
interface_change_begin(flags=0) → nil click to toggle source

Call virInterfaceChangeBegin[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceChangeBegin] to create a restore point for interface changes. Once changes have been made, conn.interface_change_commit can be used to commit the result or conn.interface_change_rollback can be used to rollback to this restore point.

static VALUE libvirt_conn_interface_change_begin(int argc, VALUE *argv,
                                                 VALUE c) {
    VALUE flags;

    rb_scan_args(argc, argv, "01", &flags);

    gen_call_void(virInterfaceChangeBegin, conn(c), connect_get(c),
                  NUM2UINT(flags));
}
interface_change_commit(flags=0) → nil click to toggle source

Call virInterfaceChangeCommit[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceChangeCommit] to commit the interface changes since the last conn.interface_change_begin.

static VALUE libvirt_conn_interface_change_commit(int argc, VALUE *argv,
                                                  VALUE c) {
    VALUE flags;

    rb_scan_args(argc, argv, "01", &flags);

    gen_call_void(virInterfaceChangeCommit, conn(c), connect_get(c),
                  NUM2UINT(flags));
}
interface_change_rollback(flags=0) → nil click to toggle source

Call virInterfaceChangeRollback[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceChangeRollback] to rollback to the restore point saved by conn.interface_change_begin.

static VALUE libvirt_conn_interface_change_rollback(int argc, VALUE *argv,
                                                    VALUE c) {
    VALUE flags;

    rb_scan_args(argc, argv, "01", &flags);

    gen_call_void(virInterfaceChangeRollback, conn(c), connect_get(c),
                  NUM2UINT(flags));
}
libversion → fixnum click to toggle source

Call virConnectGetLibVersion[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetLibVersion] to retrieve the version of the libvirt library for this connection.

static VALUE libvirt_conn_libversion(VALUE s) {
    int r;
    unsigned long v;
    virConnectPtr conn = connect_get(s);

    r = virConnectGetLibVersion(conn, &v);
    _E(r < 0, create_error(e_RetrieveError, "virConnectGetLibVersion", conn));

    return ULONG2NUM(v);
}
list_defined_domains → list click to toggle source

Call virConnectListDefinedDomains[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListDefinedDomains] to retrieve a list of inactive domain names on this connection.

static VALUE libvirt_conn_list_defined_domains(VALUE s) {
    gen_conn_list_names(s, DefinedDomains);
}
list_defined_interfaces → list click to toggle source

Call virConnectListDefinedInterfaces[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListDefinedInterfaces] to retrieve a list of inactive interface names on this connection.

static VALUE libvirt_conn_list_defined_interfaces(VALUE s) {
    gen_conn_list_names(s, DefinedInterfaces);
}
list_of_defined_networks → list click to toggle source

Call virConnectListDefinedNetworks[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListDefinedNetworks] to retrieve a list of inactive network names on this connection.

static VALUE libvirt_conn_list_defined_networks(VALUE s) {
    gen_conn_list_names(s, DefinedNetworks);
}
list_defined_storage_pools → list click to toggle source

Call virConnectListDefinedStoragePools[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListDefinedStoragePools] to retrieve a list of inactive storage pool names on this connection.

static VALUE libvirt_conn_list_defined_storage_pools(VALUE s) {
    gen_conn_list_names(s, DefinedStoragePools);
}
list_domains → list click to toggle source

Call virConnectListDomains[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListDomains] to retrieve a list of active domain IDs on this connection.

static VALUE libvirt_conn_list_domains(VALUE s) {
    int i, r, num, *ids;
    virConnectPtr conn = connect_get(s);
    VALUE result;
    int exception = 0;
    struct rb_ary_push_arg args;

    num = virConnectNumOfDomains(conn);
    _E(num < 0, create_error(e_RetrieveError, "virConnectNumOfDomains", conn));
    if (num == 0) {
        result = rb_ary_new2(num);
        return result;
    }

    ids = ALLOC_N(int, num);
    r = virConnectListDomains(conn, ids, num);
    if (r < 0) {
        xfree(ids);
        rb_exc_raise(create_error(e_RetrieveError, "virConnectListDomains",
                                  conn));
    }

    result = rb_protect(rb_ary_new2_wrap, (VALUE)&num, &exception);
    if (exception) {
        xfree(ids);
        rb_jump_tag(exception);
    }

    for (i = 0; i < num; i++) {
        args.arr = result;
        args. value = INT2NUM(ids[i]);
        rb_protect(rb_ary_push_wrap, (VALUE)&args, &exception);
        if (exception) {
            xfree(ids);
            rb_jump_tag(exception);
        }
    }
    xfree(ids);
    return result;
}
list_interfaces → list click to toggle source

Call virConnectListInterfaces[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListInterfaces] to retrieve a list of active interface names on this connection.

static VALUE libvirt_conn_list_interfaces(VALUE s) {
    gen_conn_list_names(s, Interfaces);
}
list_networks → list click to toggle source

Call virConnectListNetworks[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListNetworks] to retrieve a list of active network names on this connection.

static VALUE libvirt_conn_list_networks(VALUE s) {
    gen_conn_list_names(s, Networks);
}
list_nodedevices(cap=nil, flags=0) → list click to toggle source

Call virNodeListDevices[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeListDevices] to retrieve a list of node device names on this connection.

static VALUE libvirt_conn_list_nodedevices(int argc, VALUE *argv, VALUE c) {
    int r, num;
    virConnectPtr conn = connect_get(c);
    VALUE cap, flags_val;
    char *capstr;
    char **names;
    unsigned int flags;

    rb_scan_args(argc, argv, "02", &cap, &flags_val);

    if (NIL_P(flags_val))
        flags = 0;
    else
        flags = NUM2UINT(flags_val);

    capstr = get_string_or_nil(cap);

    num = virNodeNumOfDevices(conn, capstr, 0);
    _E(num < 0, create_error(e_RetrieveError, "virNodeNumOfDevices", conn));
    if (num == 0)
        /* if num is 0, don't call virNodeListDevices function */
        return rb_ary_new2(num);

    names = ALLOC_N(char *, num);
    r = virNodeListDevices(conn, capstr, names, num, flags);
    if (r < 0) {
        xfree(names);
        rb_exc_raise(create_error(e_RetrieveError, "virNodeListDevices", conn));
    }

    return gen_list(num, &names);
}
list_nwfilters → list click to toggle source

Call virConnectListNWFilters[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListNWFilters] to retrieve a list of network filter names on this connection.

static VALUE libvirt_conn_list_nwfilters(VALUE s) {
    gen_conn_list_names(s, NWFilters);
}
list_secrets → list click to toggle source

Call virConnectListSecrets[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListSecrets] to retrieve a list of secret UUIDs on this connection.

static VALUE libvirt_conn_list_secrets(VALUE s) {
    gen_conn_list_names(s, Secrets);
}
list_storage_pools → list click to toggle source

Call virConnectListStoragePools[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListStoragePools] to retrieve a list of active storage pool names on this connection.

static VALUE libvirt_conn_list_storage_pools(VALUE s) {
    gen_conn_list_names(s, StoragePools);
}
lookup_domain_by_id(id) → Libvirt::Domain click to toggle source

Call virDomainLookupByID[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainLookupByID] to retrieve a domain object for id.

static VALUE libvirt_conn_lookup_domain_by_id(VALUE c, VALUE id) {
    virDomainPtr dom;
    virConnectPtr conn = connect_get(c);

    dom = virDomainLookupByID(conn, NUM2INT(id));
    _E(dom == NULL, create_error(e_RetrieveError, "virDomainLookupByID",
                                 conn));

    return domain_new(dom, c);
}
lookup_domain_by_name(name) → Libvirt::Domain click to toggle source

Call virDomainLookupByName[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainLookupByName] to retrieve a domain object for name.

static VALUE libvirt_conn_lookup_domain_by_name(VALUE c, VALUE name) {
    virDomainPtr dom;
    virConnectPtr conn = connect_get(c);

    dom = virDomainLookupByName(conn, StringValueCStr(name));
    _E(dom == NULL, create_error(e_RetrieveError, "virDomainLookupByName",
                                 conn));

    return domain_new(dom, c);
}
lookup_domain_by_uuid(uuid) → Libvirt::Domain click to toggle source

Call virDomainLookupByUUIDString[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainLookupByUUIDString] to retrieve a domain object for uuid.

static VALUE libvirt_conn_lookup_domain_by_uuid(VALUE c, VALUE uuid) {
    virDomainPtr dom;
    virConnectPtr conn = connect_get(c);

    dom = virDomainLookupByUUIDString(conn, StringValueCStr(uuid));
    _E(dom == NULL, create_error(e_RetrieveError, "virDomainLookupByUUID",
                                 conn));

    return domain_new(dom, c);
}
lookup_interface_by_mac(mac) → Libvirt::Interface click to toggle source

Call virInterfaceLookupByMACString[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceLookupByMACString] to retrieve an interface object by MAC address.

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);
}
lookup_interface_by_name(name) → Libvirt::Interface click to toggle source

Call virInterfaceLookupByName[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceLookupByName] to retrieve an interface object by name.

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);
}
lookup_network_by_name(name) → Libvirt::Network click to toggle source

Call virNetworkLookupByName[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkLookupByName] to retrieve a network object by name.

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);
}
lookup_network_by_uuid(uuid) → Libvirt::Network click to toggle source

Call virNetworkLookupByUUIDString[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkLookupByUUIDString] to retrieve a network object by UUID.

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);
}
lookup_nodedevice_by_name(name) → Libvirt::NodeDevice click to toggle source

Call virNodeDeviceLookupByName[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeDeviceLookupByName] to retrieve a nodedevice object by name.

static VALUE libvirt_conn_lookup_nodedevice_by_name(VALUE c, VALUE name) {
    virNodeDevicePtr nodedev;
    virConnectPtr conn = connect_get(c);

    nodedev = virNodeDeviceLookupByName(conn, StringValueCStr(name));
    _E(nodedev == NULL, create_error(e_RetrieveError,
                                     "virNodeDeviceLookupByName", conn));

    return nodedevice_new(nodedev, c);

}
lookup_nwfilter_by_name(name) → Libvirt::NWFilter click to toggle source

Call virNWFilterLookupByName[http://www.libvirt.org/html/libvirt-libvirt.html#virNWFilterLookupByName] to retrieve a network filter object by name.

static VALUE libvirt_conn_lookup_nwfilter_by_name(VALUE c, VALUE name) {
    virNWFilterPtr nwfilter;
    virConnectPtr conn = connect_get(c);

    nwfilter = virNWFilterLookupByName(conn, StringValueCStr(name));
    _E(nwfilter == NULL, create_error(e_RetrieveError,
                                      "virNWFilterLookupByName", conn));

    return nwfilter_new(nwfilter, c);
}
lookup_nwfilter_by_uuid(uuid) → Libvirt::NWFilter click to toggle source

Call virNWFilterLookupByUUIDString[http://www.libvirt.org/html/libvirt-libvirt.html#virNWFilterLookupByUUIDString] to retrieve a network filter object by UUID.

static VALUE libvirt_conn_lookup_nwfilter_by_uuid(VALUE c, VALUE uuid) {
    virNWFilterPtr nwfilter;
    virConnectPtr conn = connect_get(c);

    nwfilter = virNWFilterLookupByUUIDString(conn, StringValueCStr(uuid));
    _E(nwfilter == NULL, create_error(e_RetrieveError,
                                      "virNWFilterLookupByUUIDString", conn));

    return nwfilter_new(nwfilter, c);
}
lookup_secret_by_usage(usagetype, usageID) → Libvirt::Secret click to toggle source

Call virSecretLookupByUsage[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretLookupByUsage] to retrieve a secret by usagetype.

static VALUE libvirt_conn_lookup_secret_by_usage(VALUE c, VALUE usagetype,
                                                 VALUE usageID) {
    virSecretPtr secret;
    virConnectPtr conn = connect_get(c);

    secret = virSecretLookupByUsage(conn, NUM2UINT(usagetype),
                                    StringValueCStr(usageID));
    _E(secret == NULL, create_error(e_RetrieveError, "virSecretLookupByUsage",
                                    conn));

    return secret_new(secret, c);
}
lookup_secret_by_uuid(uuid) → Libvirt::Secret click to toggle source

Call virSecretLookupByUUID[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretLookupByUUID] to retrieve a network object from uuid.

static VALUE libvirt_conn_lookup_secret_by_uuid(VALUE c, VALUE uuid) {
    virSecretPtr secret;
    virConnectPtr conn = connect_get(c);

    secret = virSecretLookupByUUIDString(conn, StringValueCStr(uuid));
    _E(secret == NULL, create_error(e_RetrieveError, "virSecretLookupByUUID",
                                    conn));

    return secret_new(secret, c);
}
lookup_storage_pool_by_name(name) → Libvirt::StoragePool click to toggle source

Call virStoragePoolLookupByName[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolLookupByName] to retrieve a storage pool object by name.

static VALUE libvirt_conn_lookup_pool_by_name(VALUE c, VALUE name) {
    virStoragePoolPtr pool;
    virConnectPtr conn = connect_get(c);

    pool = virStoragePoolLookupByName(conn, StringValueCStr(name));
    _E(pool == NULL, create_error(e_RetrieveError, "virStoragePoolLookupByName",
                                  conn));

    return pool_new(pool, c);
}
lookup_storage_pool_by_uuid(uuid) → Libvirt::StoragePool click to toggle source

Call virStoragePoolLookupByUUIDString[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolLookupByUUIDString] to retrieve a storage pool object by uuid.

static VALUE libvirt_conn_lookup_pool_by_uuid(VALUE c, VALUE uuid) {
    virStoragePoolPtr pool;
    virConnectPtr conn = connect_get(c);

    pool = virStoragePoolLookupByUUIDString(conn, StringValueCStr(uuid));
    _E(pool == NULL, create_error(e_RetrieveError, "virStoragePoolLookupByUUID",
                                  conn));

    return pool_new(pool, c);
}
max_vcpus(type=nil) → fixnum click to toggle source

Call virConnectGetMaxVcpus[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetMaxVcpus] to retrieve the maximum number of virtual cpus supported by the hypervisor for this connection.

static VALUE libvirt_conn_max_vcpus(int argc, VALUE *argv, VALUE s) {
    VALUE type;

    rb_scan_args(argc, argv, "01", &type);

    gen_call_int(virConnectGetMaxVcpus, conn(s), connect_get(s),
                 get_string_or_nil(type));
}
node_cells_free_memory(startCell=0, maxCells=#nodeCells) → list click to toggle source

Call virNodeGetCellsFreeMemory[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeGetCellsFreeMemory] to retrieve the amount of free memory in each NUMA cell on the host for this connection.

static VALUE libvirt_conn_node_cells_free_memory(int argc, VALUE *argv,
                                                 VALUE s) {
    int r;
    virConnectPtr conn = connect_get(s);
    VALUE cells;
    VALUE start, max;
    unsigned long long *freeMems;
    virNodeInfo nodeinfo;
    int i;
    unsigned int startCell, maxCells;

    rb_scan_args(argc, argv, "02", &start, &max);

    if (NIL_P(start))
        startCell = 0;
    else
        startCell = NUM2UINT(start);

    if (NIL_P(max)) {
        r = virNodeGetInfo(conn, &nodeinfo);
        _E(r < 0, create_error(e_RetrieveError, "virNodeGetInfo", conn));
        maxCells = nodeinfo.nodes;
    }
    else
        maxCells = NUM2UINT(max);

    freeMems = ALLOC_N(unsigned long long, maxCells);

    r = virNodeGetCellsFreeMemory(conn, freeMems, startCell, maxCells);
    if (r < 0) {
        xfree(freeMems);
        rb_exc_raise(create_error(e_RetrieveError, "virNodeGetCellsFreeMemory",
                                  conn));
    }

    cells = rb_ary_new2(r);
    for (i = 0; i < r; i++)
        rb_ary_push(cells, ULL2NUM(freeMems[i]));
    xfree(freeMems);

    return cells;
}
node_free_memory → fixnum click to toggle source

Call virNodeGetFreeMemory[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeGetFreeMemory] to retrieve the amount of free memory available on the host for this connection.

static VALUE libvirt_conn_node_free_memory(VALUE s) {
    virConnectPtr conn = connect_get(s);
    unsigned long long freemem;

    freemem = virNodeGetFreeMemory(conn);

    _E(freemem == 0, create_error(e_RetrieveError, "virNodeGetFreeMemory",
                                  conn));

    return ULL2NUM(freemem);
}
node_get_info → Libvirt::Connect::Nodeinfo click to toggle source

Call virNodeGetInfo[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeGetInfo] to retrieve information about the node for this connection.

static VALUE libvirt_conn_node_get_info(VALUE s) {
    int r;
    virConnectPtr conn = connect_get(s);
    virNodeInfo nodeinfo;
    VALUE result;

    r = virNodeGetInfo(conn, &nodeinfo);
    _E(r < 0, create_error(e_RetrieveError, "virNodeGetInfo", conn));

    result = rb_class_new_instance(0, NULL, c_node_info);
    rb_iv_set(result, "@model", rb_str_new2(nodeinfo.model));
    rb_iv_set(result, "@memory", ULONG2NUM(nodeinfo.memory));
    rb_iv_set(result, "@cpus", UINT2NUM(nodeinfo.cpus));
    rb_iv_set(result, "@mhz", UINT2NUM(nodeinfo.mhz));
    rb_iv_set(result, "@nodes", UINT2NUM(nodeinfo.nodes));
    rb_iv_set(result, "@sockets", UINT2NUM(nodeinfo.sockets));
    rb_iv_set(result, "@cores", UINT2NUM(nodeinfo.cores));
    rb_iv_set(result, "@threads", UINT2NUM(nodeinfo.threads));

    return result;
}
node_get_security_model → Libvirt::Connect::NodeSecurityModel click to toggle source

Call virNodeGetSecurityModel[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeGetSecurityModel] to retrieve the security model in use on the host for this connection.

static VALUE libvirt_conn_node_get_security_model(VALUE s) {
    virSecurityModel secmodel;
    virConnectPtr conn = connect_get(s);
    int r;
    VALUE result;

    r = virNodeGetSecurityModel(conn, &secmodel);
    _E(r < 0, create_error(e_RetrieveError, "virNodeGetSecurityModel", conn));

    result = rb_class_new_instance(0, NULL, c_node_security_model);
    rb_iv_set(result, "@model", rb_str_new2(secmodel.model));
    rb_iv_set(result, "@doi", rb_str_new2(secmodel.doi));

    return result;
}
num_of_defined_domains → fixnum click to toggle source

Call virConnectNumOfDefinedDomains[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfDefinedDomains] to retrieve the number of inactive domains on this connection.

static VALUE libvirt_conn_num_of_defined_domains(VALUE s) {
    gen_conn_num_of(s, DefinedDomains);
}
num_of_defined_interfaces → fixnum click to toggle source

Call virConnectNumOfDefinedInterfaces[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfDefinedInterfaces] to retrieve the number of inactive interfaces on this connection.

static VALUE libvirt_conn_num_of_defined_interfaces(VALUE s) {
    gen_conn_num_of(s, DefinedInterfaces);
}
num_of_defined_networks → fixnum click to toggle source

Call virConnectNumOfDefinedNetworks[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfDefinedNetworks] to retrieve the number of inactive networks on this connection.

static VALUE libvirt_conn_num_of_defined_networks(VALUE s) {
    gen_conn_num_of(s, DefinedNetworks);
}
num_of_defined_storage_pools → fixnum click to toggle source

Call virConnectNumOfDefinedStoragePools[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfDefinedStoragePools] to retrieve the number of inactive storage pools on this connection.

static VALUE libvirt_conn_num_of_defined_storage_pools(VALUE s) {
    gen_conn_num_of(s, DefinedStoragePools);
}
num_of_domains → fixnum click to toggle source

Call virConnectNumOfDomains[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfDomains] to retrieve the number of active domains on this connection.

static VALUE libvirt_conn_num_of_domains(VALUE s) {
    gen_conn_num_of(s, Domains);
}
num_of_interfaces → fixnum click to toggle source

Call virConnectNumOfInterfaces[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfInterfaces] to retrieve the number of active interfaces on this connection.

static VALUE libvirt_conn_num_of_interfaces(VALUE s) {
    gen_conn_num_of(s, Interfaces);
}
num_of_networks → fixnum click to toggle source

Call virConnectNumOfNetworks[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfNetworks] to retrieve the number of active networks on this connection.

static VALUE libvirt_conn_num_of_networks(VALUE s) {
    gen_conn_num_of(s, Networks);
}
num_of_nodedevices(cap=nil, flags=0) → fixnum click to toggle source

Call virNodeNumOfDevices[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeNumOfDevices] to retrieve the number of node devices on this connection.

static VALUE libvirt_conn_num_of_nodedevices(int argc, VALUE *argv, VALUE c) {
    int result;
    virConnectPtr conn = connect_get(c);
    VALUE cap, flags;

    rb_scan_args(argc, argv, "02", &cap, &flags);

    if (NIL_P(flags))
        flags = INT2NUM(0);

    result = virNodeNumOfDevices(conn, get_string_or_nil(cap), NUM2UINT(flags));
    _E(result < 0, create_error(e_RetrieveError, "virNodeNumOfDevices", conn));

    return INT2NUM(result);
}
num_of_nwfilters → fixnum click to toggle source

Call virConnectNumOfNWFilters[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfNWFilters] to retrieve the number of network filters on this connection.

static VALUE libvirt_conn_num_of_nwfilters(VALUE s) {
    gen_conn_num_of(s, NWFilters);
}
num_of_secrets → fixnum click to toggle source

Call virConnectNumOfSecrets[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfSecrets] to retrieve the number of secrets on this connection.

static VALUE libvirt_conn_num_of_secrets(VALUE s) {
    gen_conn_num_of(s, Secrets);
}
num_of_storage_pools → fixnum click to toggle source

Call virConnectNumOfStoragePools[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfStoragePools] to retrieve the number of active storage pools on this connection.

static VALUE libvirt_conn_num_of_storage_pools(VALUE s) {
    gen_conn_num_of(s, StoragePools);
}
secure? → [True|False] click to toggle source

Call virConnectIsSecure[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectIsSecure] to determine if the connection is secure.

static VALUE libvirt_conn_secure_p(VALUE s) {
    gen_call_truefalse(virConnectIsSecure, conn(s), connect_get(s));
}
stream(flags=0) → Libvirt::Stream click to toggle source

Call virStreamNew[http://www.libvirt.org/html/libvirt-libvirt.html#virStreamNew] to create a new stream.

static VALUE libvirt_conn_stream(int argc, VALUE *argv, VALUE c) {
    VALUE flags;
    virStreamPtr stream;

    rb_scan_args(argc, argv, "01", &flags);

    if (NIL_P(flags))
        flags = INT2NUM(0);

    stream = virStreamNew(connect_get(c), NUM2UINT(flags));

    _E(stream == NULL, create_error(e_RetrieveError, "virStreamNew", conn(c)));

    return stream_new(stream, c);
}
sys_info(flags=0) → string click to toggle source

Call virConnectGetSysinfo[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetSysinfo] to get machine-specific information about the hypervisor. This may include data such as the host UUID, the BIOS version, etc.

static VALUE libvirt_conn_get_sys_info(int argc, VALUE *argv, VALUE c) {
    VALUE flags;

    rb_scan_args(argc, argv, "01", &flags);

    if (NIL_P(flags))
        flags = INT2NUM(0);

    gen_call_string(virConnectGetSysinfo, conn(c), 1, connect_get(c),
                    NUM2UINT(flags));
}
type → string click to toggle source

Call virConnectGetType[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetType] to retrieve the type of hypervisor for this connection.

static VALUE libvirt_conn_type(VALUE s) {
    gen_call_string(virConnectGetType, conn(s), 0, connect_get(s));
}
uri → string click to toggle source

Call virConnectGetURI[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetURI] to retrieve the canonical URI for this connection.

static VALUE libvirt_conn_uri(VALUE s) {
    gen_call_string(virConnectGetURI, conn(s), 1, connect_get(s));
}
version → fixnum click to toggle source

Call virConnectGetVersion[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetVersion] to retrieve the version of the hypervisor for this connection.

static VALUE libvirt_conn_version(VALUE s) {
    int r;
    unsigned long v;
    virConnectPtr conn = connect_get(s);

    r = virConnectGetVersion(conn, &v);
    _E(r < 0, create_error(e_RetrieveError, "virConnectGetVersion", conn));

    return ULONG2NUM(v);
}