File Coverage

blib/lib/Sys/Async/Virt/StoragePool.pm

Criterion	Covered	Total	%
statement	26	137	18.9
branch			n/a
condition	0	8	0.0
subroutine	9	32	28.1
pod	21	23	91.3
total	56	200	28.0

####################################################################
#
#     This file was generated using XDR::Parse version v1.0.1
#                   and LibVirt version v12.1.0
#
#      Don't edit this file, use the source template instead
#
#                 ANY CHANGES HERE WILL BE LOST !
#
####################################################################


use v5.26;
use warnings;
use experimental 'signatures';
use Future::AsyncAwait;
use Object::Pad;

class Sys::Async::Virt::StoragePool v0.6.1;

use Carp qw(croak);
use Log::Any qw($log);

use Protocol::Sys::Virt::Remote::XDR v12.1.0;
my $remote = 'Protocol::Sys::Virt::Remote::XDR';

use constant {
    INACTIVE           => 0,
    BUILDING           => 1,
    RUNNING            => 2,
    DEGRADED           => 3,
    INACCESSIBLE       => 4,
    BUILD_NEW          => 0,
    BUILD_REPAIR       => (1 << 0),
    BUILD_RESIZE       => (1 << 1),
    BUILD_NO_OVERWRITE => (1 << 2),
    BUILD_OVERWRITE    => (1 << 3),
    DELETE_NORMAL      => 0,
    DELETE_ZEROED      => 1 << 0,
    XML_INACTIVE       => (1 << 0),
    EVENT_DEFINED      => 0,
    EVENT_UNDEFINED    => 1,
    EVENT_STARTED      => 2,
    EVENT_STOPPED      => 3,
    EVENT_CREATED      => 4,
    EVENT_DELETED      => 5,
};


field $_rpc_id :param :reader;
field $_client :param :reader;

method name() {
    return $_rpc_id->{name};
}

method uuid() {
    return $_rpc_id->{uuid};
}

method uuid_string() {
    return join( '-', unpack('H8H4H4H4H12', $_rpc_id->{uuid}) );
}


method build($flags = 0) {
    return $_client->_call(
        $remote->PROC_STORAGE_POOL_BUILD,
        { pool => $_rpc_id, flags => $flags // 0 }, empty => 1 );
}

method create($flags = 0) {
    return $_client->_call(
        $remote->PROC_STORAGE_POOL_CREATE,
        { pool => $_rpc_id, flags => $flags // 0 }, empty => 1 );
}

method delete($flags = 0) {
    return $_client->_call(
        $remote->PROC_STORAGE_POOL_DELETE,
        { pool => $_rpc_id, flags => $flags // 0 }, empty => 1 );
}

method destroy() {
    return $_client->_call(
        $remote->PROC_STORAGE_POOL_DESTROY,
        { pool => $_rpc_id }, empty => 1 );
}

async method get_autostart() {
    return await $_client->_call(
        $remote->PROC_STORAGE_POOL_GET_AUTOSTART,
        { pool => $_rpc_id }, unwrap => 'autostart' );
}

method get_info() {
    return $_client->_call(
        $remote->PROC_STORAGE_POOL_GET_INFO,
        { pool => $_rpc_id } );
}

async method get_xml_desc($flags = 0) {
    return await $_client->_call(
        $remote->PROC_STORAGE_POOL_GET_XML_DESC,
        { pool => $_rpc_id, flags => $flags // 0 }, unwrap => 'xml' );
}

async method is_active() {
    return await $_client->_call(
        $remote->PROC_STORAGE_POOL_IS_ACTIVE,
        { pool => $_rpc_id }, unwrap => 'active' );
}

async method is_persistent() {
    return await $_client->_call(
        $remote->PROC_STORAGE_POOL_IS_PERSISTENT,
        { pool => $_rpc_id }, unwrap => 'persistent' );
}

async method list_all_volumes($flags = 0) {
    return await $_client->_call(
        $remote->PROC_STORAGE_POOL_LIST_ALL_VOLUMES,
        { pool => $_rpc_id, need_results => $remote->STORAGE_VOL_LIST_MAX, flags => $flags // 0 }, unwrap => 'vols' );
}

async method list_volumes() {
    return await $_client->_call(
        $remote->PROC_STORAGE_POOL_LIST_VOLUMES,
        { pool => $_rpc_id, maxnames => $remote->STORAGE_VOL_LIST_MAX }, unwrap => 'names' );
}

async method num_of_volumes() {
    return await $_client->_call(
        $remote->PROC_STORAGE_POOL_NUM_OF_VOLUMES,
        { pool => $_rpc_id }, unwrap => 'num' );
}

method refresh($flags = 0) {
    return $_client->_call(
        $remote->PROC_STORAGE_POOL_REFRESH,
        { pool => $_rpc_id, flags => $flags // 0 }, empty => 1 );
}

method set_autostart($autostart) {
    return $_client->_call(
        $remote->PROC_STORAGE_POOL_SET_AUTOSTART,
        { pool => $_rpc_id, autostart => $autostart }, empty => 1 );
}

method undefine() {
    return $_client->_call(
        $remote->PROC_STORAGE_POOL_UNDEFINE,
        { pool => $_rpc_id }, empty => 1 );
}

async method vol_create_xml($xml, $flags = 0) {
    return await $_client->_call(
        $remote->PROC_STORAGE_VOL_CREATE_XML,
        { pool => $_rpc_id, xml => $xml, flags => $flags // 0 }, unwrap => 'vol' );
}

async method vol_create_xml_from($xml, $clonevol, $flags = 0) {
    return await $_client->_call(
        $remote->PROC_STORAGE_VOL_CREATE_XML_FROM,
        { pool => $_rpc_id, xml => $xml, clonevol => $clonevol, flags => $flags // 0 }, unwrap => 'vol' );
}

async method vol_lookup_by_name($name) {
    return await $_client->_call(
        $remote->PROC_STORAGE_VOL_LOOKUP_BY_NAME,
        { pool => $_rpc_id, name => $name }, unwrap => 'vol' );
}



1;


__END__