## GVirStoragePool GVirStoragePool |

## Synopsis

    struct              GVirStoragePool;
    struct              GVirStoragePoolClass;
    enum                GVirStoragePoolState;
    struct              GVirStoragePoolInfo;
    const gchar *       gvir_storage_pool_get_name          (GVirStoragePool *pool);
    const gchar *       gvir_storage_pool_get_uuid          (GVirStoragePool *pool);
    gboolean            gvir_storage_pool_get_active        (GVirStoragePool *pool);
    gboolean            gvir_storage_pool_get_persistent    (GVirStoragePool *pool);
    GVirConfigStoragePool * gvir_storage_pool_get_config    (GVirStoragePool *pool,
                                                             guint flags,
                                                             GError **err);
    GVirStoragePoolInfo * gvir_storage_pool_get_info        (GVirStoragePool *pool,
                                                             GError **err);
    gboolean            gvir_storage_pool_refresh           (GVirStoragePool *pool,
                                                             GCancellable *cancellable,
                                                             GError **err);
    void                gvir_storage_pool_refresh_async     (GVirStoragePool *pool,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            gvir_storage_pool_refresh_finish    (GVirStoragePool *pool,
                                                             GAsyncResult *result,
                                                             GError **err);
    GList *             gvir_storage_pool_get_volumes       (GVirStoragePool *pool);
    GVirStorageVol *    gvir_storage_pool_get_volume        (GVirStoragePool *pool,
                                                             const gchar *name);
    GVirStorageVol *    gvir_storage_pool_create_volume     (GVirStoragePool *pool,
                                                             GVirConfigStorageVol *conf,
                                                             GError **err);
    gboolean            gvir_storage_pool_build             (GVirStoragePool *pool,
                                                             guint flags,
                                                             GError **err);
    void                gvir_storage_pool_build_async       (GVirStoragePool *pool,
                                                             guint flags,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            gvir_storage_pool_build_finish      (GVirStoragePool *pool,
                                                             GAsyncResult *result,
                                                             GError **err);
    gboolean            gvir_storage_pool_undefine          (GVirStoragePool *pool,
                                                             GError **err);
    void                gvir_storage_pool_undefine_async    (GVirStoragePool *pool,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            gvir_storage_pool_undefine_finish   (GVirStoragePool *pool,
                                                             GAsyncResult *result,
                                                             GError **err);
    gboolean            gvir_storage_pool_start             (GVirStoragePool *pool,
                                                             guint flags,
                                                             GError **err);
    void                gvir_storage_pool_start_async       (GVirStoragePool *pool,
                                                             guint flags,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            gvir_storage_pool_start_finish      (GVirStoragePool *pool,
                                                             GAsyncResult *result,
                                                             GError **err);
    gboolean            gvir_storage_pool_stop              (GVirStoragePool *pool,
                                                             GError **err);
    void                gvir_storage_pool_stop_async        (GVirStoragePool *pool,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            gvir_storage_pool_stop_finish       (GVirStoragePool *pool,
                                                             GAsyncResult *result,
                                                             GError **err);
    gboolean            gvir_storage_pool_delete            (GVirStoragePool *pool,
                                                             guint flags,
                                                             GError **err);
    void                gvir_storage_pool_delete_async      (GVirStoragePool *pool,
                                                             guint flags,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            gvir_storage_pool_delete_finish     (GVirStoragePool *pool,
                                                             GAsyncResult *result,
                                                             GError **err);

## Object Hierarchy

      GObject
       +----GVirStoragePool

      GBoxed
       +----GVirStoragePoolInfo

## Properties

      "handle"                   GVirStoragePoolHandle*  : Read / Write / Construct Only

## Description

## Details

### struct GVirStoragePool

    struct GVirStoragePool;

### struct GVirStoragePoolClass

    struct GVirStoragePoolClass {
        GObjectClass parent_class;

        gpointer padding[20];
    };

### enum GVirStoragePoolState

    typedef enum {
        GVIR_STORAGE_POOL_STATE_INACTIVE     = 0, /* Not running */
        GVIR_STORAGE_POOL_STATE_BUILDING     = 1, /* Initializing pool, not available */
        GVIR_STORAGE_POOL_STATE_RUNNING      = 2, /* Running normally */
        GVIR_STORAGE_POOL_STATE_DEGRADED     = 3, /* Running degraded */
        GVIR_STORAGE_POOL_STATE_INACCESSIBLE = 4, /* Running, but not accessible */
    } GVirStoragePoolState;

`GVIR_STORAGE_POOL_STATE_INACTIVE` |
`GVIR_STORAGE_POOL_STATE_BUILDING` |
`GVIR_STORAGE_POOL_STATE_RUNNING` |
`GVIR_STORAGE_POOL_STATE_DEGRADED` |
`GVIR_STORAGE_POOL_STATE_INACCESSIBLE` |

### struct GVirStoragePoolInfo

    struct GVirStoragePoolInfo {
        GVirStoragePoolState state; /* the state */
        guint64 capacity;           /* Logical size bytes */
        guint64 allocation;         /* Current allocation bytes */
        guint64 available;          /* Remaining free space bytes */
    };

### gvir_storage_pool_get_name ()

    const gchar *       gvir_storage_pool_get_name          (GVirStoragePool *pool);

### gvir_storage_pool_get_uuid ()

    const gchar *       gvir_storage_pool_get_uuid          (GVirStoragePool *pool);

### gvir_storage_pool_get_active ()

    gboolean            gvir_storage_pool_get_active        (GVirStoragePool *pool);

### gvir_storage_pool_get_persistent ()

    gboolean            gvir_storage_pool_get_persistent    (GVirStoragePool *pool);

### gvir_storage_pool_get_config ()

    GVirConfigStoragePool * gvir_storage_pool_get_config    (GVirStoragePool *pool,
                                                             guint flags,
                                                             GError **err);

`pool` : | the storage_pool
`flags` : | the flags
`err` : | Place-holder for possible errors
Returns : | the config. The returned object should be unreffed with `g_object_unref()` when no longer needed. [transfer full]

### gvir_storage_pool_get_info ()

    GVirStoragePoolInfo * gvir_storage_pool_get_info        (GVirStoragePool *pool,
                                                             GError **err);

`pool` : | the storage_pool
`err` : | Place-holder for possible errors
Returns : | the info. The returned object should be unreffed with `g_object_unref()` when no longer needed. [transfer full]

### gvir_storage_pool_refresh ()

    gboolean            gvir_storage_pool_refresh           (GVirStoragePool *pool,
                                                             GCancellable *cancellable,
                                                             GError **err);

`pool` : | the storage pool
`cancellable` : | cancellation object. [allow-none][transfer none]

### gvir_storage_pool_refresh_async ()

    void                gvir_storage_pool_refresh_async     (GVirStoragePool *pool,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

`pool` : | the storage pool
`cancellable` : | cancellation object. [allow-none][transfer none]
`callback` : | completion callback. [scope async]
`user_data` : | opaque data for callback. [closure]

### gvir_storage_pool_refresh_finish ()

    gboolean            gvir_storage_pool_refresh_finish    (GVirStoragePool *pool,
                                                             GAsyncResult *result,
                                                             GError **err);

`pool` : | the storage pool
`result` : | async method result. [transfer none]

### gvir_storage_pool_get_volumes ()

    GList *             gvir_storage_pool_get_volumes       (GVirStoragePool *pool);

`pool` : | the storage pool
Returns : | List of GVirStorageVol. The returned list should be freed with `g_list_free()`, after its elements have been unreffed with `g_object_unref()`. [element-type LibvirtGObject.StorageVol][transfer full]

### gvir_storage_pool_get_volume ()

    GVirStorageVol *    gvir_storage_pool_get_volume        (GVirStoragePool *pool,
                                                             const gchar *name);

`pool` : | the storage pool
`name` : | Name of the requested storage volume
Returns : | the GVirStorageVol, or NULL. The returned object should be unreffed with `g_object_unref()` when no longer needed. [transfer full]

### gvir_storage_pool_create_volume ()

    GVirStorageVol *    gvir_storage_pool_create_volume     (GVirStoragePool *pool,
                                                             GVirConfigStorageVol *conf,
                                                             GError **err);

`pool` : | the storage pool in which to create the volume
`conf` : | the configuration for the new volume
`err` : | Place-holder for possible errors
Returns : | the newly created volume. The returned object should be unreffed with `g_object_unref()` when no longer needed. [transfer full]

### gvir_storage_pool_build ()

    gboolean            gvir_storage_pool_build             (GVirStoragePool *pool,
                                                             guint flags,
                                                             GError **err);

`pool` : | the storage pool to build
`flags` : | the flags
`err` : | return location for any GError
Returns : | True on success, False otherwise.

### gvir_storage_pool_build_async ()

    void                gvir_storage_pool_build_async       (GVirStoragePool *pool,
                                                             guint flags,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

`pool` : | the storage pool to build
`flags` : | the flags
`cancellable` : | cancellation object. [allow-none][transfer none]
`callback` : | completion callback. [scope async]
`user_data` : | opaque data for callback. [closure]

### gvir_storage_pool_build_finish ()

    gboolean            gvir_storage_pool_build_finish      (GVirStoragePool *pool,
                                                             GAsyncResult *result,
                                                             GError **err);

`pool` : | the storage pool to build
`result` : | async method result. [transfer none]
`err` : | return location for any GError
Returns : | True on success, False otherwise.

### gvir_storage_pool_undefine ()

    gboolean            gvir_storage_pool_undefine          (GVirStoragePool *pool,
                                                             GError **err);

`pool` : | the storage pool to undefine
`err` : | return location for any GError
Returns : | True on success, False otherwise.

### gvir_storage_pool_undefine_async ()

    void                gvir_storage_pool_undefine_async    (GVirStoragePool *pool,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

`pool` : | the storage pool to undefine
`cancellable` : | cancellation object. [allow-none][transfer none]
`callback` : | completion callback. [scope async]
`user_data` : | opaque data for callback. [closure]

### gvir_storage_pool_undefine_finish ()

    gboolean            gvir_storage_pool_undefine_finish   (GVirStoragePool *pool,
                                                             GAsyncResult *result,
                                                             GError **err);

`pool` : | the storage pool to undefine
`result` : | async method result. [transfer none]
`err` : | return location for any GError
Returns : | True on success, False otherwise.

### gvir_storage_pool_start ()

    gboolean            gvir_storage_pool_start             (GVirStoragePool *pool,
                                                             guint flags,
                                                             GError **err);

`pool` : | the storage pool to start
`flags` : | the flags
`err` : | return location for any GError
Returns : | True on success, False otherwise.

### gvir_storage_pool_start_async ()

    void                gvir_storage_pool_start_async       (GVirStoragePool *pool,
                                                             guint flags,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

`pool` : | the storage pool to start
`flags` : | the flags
`cancellable` : | cancellation object. [allow-none][transfer none]
`callback` : | completion callback. [scope async]
`user_data` : | opaque data for callback. [closure]

### gvir_storage_pool_start_finish ()

    gboolean            gvir_storage_pool_start_finish      (GVirStoragePool *pool,
                                                             GAsyncResult *result,
                                                             GError **err);

`pool` : | the storage pool to start
`result` : | async method result. [transfer none]
`err` : | return location for any GError
Returns : | True on success, False otherwise.

### gvir_storage_pool_stop ()

    gboolean            gvir_storage_pool_stop              (GVirStoragePool *pool,
                                                             GError **err);

`pool` : | the storage pool to stop
`err` : | return location for any GError
Returns : | True on success, False otherwise.

### gvir_storage_pool_stop_async ()

    void                gvir_storage_pool_stop_async        (GVirStoragePool *pool,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

`pool` : | the storage pool to stop
`cancellable` : | cancellation object. [allow-none][transfer none]
`callback` : | completion callback. [scope async]
`user_data` : | opaque data for callback. [closure]

### gvir_storage_pool_stop_finish ()

    gboolean            gvir_storage_pool_stop_finish       (GVirStoragePool *pool,
                                                             GAsyncResult *result,
                                                             GError **err);

`pool` : | the storage pool to stop
`result` : | async method result. [transfer none]
`err` : | return location for any GError
Returns : | True on success, False otherwise.

### gvir_storage_pool_delete ()

    gboolean            gvir_storage_pool_delete            (GVirStoragePool *pool,
                                                             guint flags,
                                                             GError **err);

`pool` : | the storage pool to delete
`flags` : | the flags
`err` : | return location for any GError
Returns : | True on success, False otherwise.

### gvir_storage_pool_delete_async ()

    void                gvir_storage_pool_delete_async      (GVirStoragePool *pool,
                                                             guint flags,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

`pool` : | the storage pool to delete
`flags` : | the flags
`cancellable` : | cancellation object. [allow-none][transfer none]
`callback` : | completion callback. [scope async]
`user_data` : | opaque data for callback. [closure]

### gvir_storage_pool_delete_finish ()

    gboolean            gvir_storage_pool_delete_finish     (GVirStoragePool *pool,
                                                             GAsyncResult *result,
                                                             GError **err);

`pool` : | the storage pool to delete
`result` : | async method result. [transfer none]
`err` : | return location for any GError
Returns : | True on success, False otherwise.

## Property Details

### The `"handle"` property

      "handle"                   GVirStoragePoolHandle*  : Read / Write / Construct Only

The storage_pool handle.