[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

[libvirt] [PATCH 05/13] virsh: Split cmds of storage pool group from virsh.c



This splits commands of storage pool group into virsh-pool.c,
The helpers not for common use are moved too. Standard copyright
is added for the new file.

* tools/virsh.c:
  Remove commands for storage storage pool and a few helpers.
  (vshCommandOptVol, vshCommandOptVolBy).

* tools/virsh-pool.c:
  New file, filled with commands of storage pool group and its
  helpers.
---
 tools/virsh-pool.c | 1415 +++++++++++++++++++++++++++++++++++++++++++
 tools/virsh.c      | 1690 +++++-----------------------------------------------
 2 files changed, 1556 insertions(+), 1549 deletions(-)
 create mode 100644 tools/virsh-pool.c

diff --git a/tools/virsh-pool.c b/tools/virsh-pool.c
new file mode 100644
index 0000000..6a1208f
--- /dev/null
+++ b/tools/virsh-pool.c
@@ -0,0 +1,1415 @@
+/*
+ * virsh-pool.c: Commands to manage storage pool
+ *
+ * Copyright (C) 2005, 2007-2012 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, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ *  Daniel Veillard <veillard redhat com>
+ *  Karel Zak <kzak redhat com>
+ *  Daniel P. Berrange <berrange redhat com>
+ *
+ */
+
+/* default is lookup by Name and UUID */
+#define vshCommandOptPool(_ctl, _cmd, _optname, _name)           \
+    vshCommandOptPoolBy(_ctl, _cmd, _optname, _name,             \
+                           VSH_BYUUID|VSH_BYNAME)
+
+static virStoragePoolPtr
+vshCommandOptPoolBy(vshControl *ctl, const vshCmd *cmd, const char *optname,
+                    const char **name, int flag)
+{
+    virStoragePoolPtr pool = NULL;
+    const char *n = NULL;
+
+    if (vshCommandOptString(cmd, optname, &n) <= 0)
+        return NULL;
+
+    vshDebug(ctl, VSH_ERR_INFO, "%s: found option <%s>: %s\n",
+             cmd->def->name, optname, n);
+
+    if (name)
+        *name = n;
+
+    /* try it by UUID */
+    if ((flag & VSH_BYUUID) && strlen(n) == VIR_UUID_STRING_BUFLEN-1) {
+        vshDebug(ctl, VSH_ERR_DEBUG, "%s: <%s> trying as pool UUID\n",
+                 cmd->def->name, optname);
+        pool = virStoragePoolLookupByUUIDString(ctl->conn, n);
+    }
+    /* try it by NAME */
+    if (pool == NULL && (flag & VSH_BYNAME)) {
+        vshDebug(ctl, VSH_ERR_DEBUG, "%s: <%s> trying as pool NAME\n",
+                 cmd->def->name, optname);
+        pool = virStoragePoolLookupByName(ctl->conn, n);
+    }
+
+    if (!pool)
+        vshError(ctl, _("failed to get pool '%s'"), n);
+
+    return pool;
+}
+
+/*
+ * "pool-autostart" command
+ */
+static const vshCmdInfo info_pool_autostart[] = {
+    {"help", N_("autostart a pool")},
+    {"desc",
+     N_("Configure a pool to be automatically started at boot.")},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_pool_autostart[] = {
+    {"pool",  VSH_OT_DATA, VSH_OFLAG_REQ, N_("pool name or uuid")},
+    {"disable", VSH_OT_BOOL, 0, N_("disable autostarting")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdPoolAutostart(vshControl *ctl, const vshCmd *cmd)
+{
+    virStoragePoolPtr pool;
+    const char *name;
+    int autostart;
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (!(pool = vshCommandOptPool(ctl, cmd, "pool", &name)))
+        return false;
+
+    autostart = !vshCommandOptBool(cmd, "disable");
+
+    if (virStoragePoolSetAutostart(pool, autostart) < 0) {
+        if (autostart)
+            vshError(ctl, _("failed to mark pool %s as autostarted"), name);
+        else
+            vshError(ctl, _("failed to unmark pool %s as autostarted"), name);
+        virStoragePoolFree(pool);
+        return false;
+    }
+
+    if (autostart)
+        vshPrint(ctl, _("Pool %s marked as autostarted\n"), name);
+    else
+        vshPrint(ctl, _("Pool %s unmarked as autostarted\n"), name);
+
+    virStoragePoolFree(pool);
+    return true;
+}
+
+/*
+ * "pool-create" command
+ */
+static const vshCmdInfo info_pool_create[] = {
+    {"help", N_("create a pool from an XML file")},
+    {"desc", N_("Create a pool.")},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_pool_create[] = {
+    {"file", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("file containing an XML pool description")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdPoolCreate(vshControl *ctl, const vshCmd *cmd)
+{
+    virStoragePoolPtr pool;
+    const char *from = NULL;
+    bool ret = true;
+    char *buffer;
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (vshCommandOptString(cmd, "file", &from) <= 0)
+        return false;
+
+    if (virFileReadAll(from, VIRSH_MAX_XML_FILE, &buffer) < 0)
+        return false;
+
+    pool = virStoragePoolCreateXML(ctl->conn, buffer, 0);
+    VIR_FREE(buffer);
+
+    if (pool != NULL) {
+        vshPrint(ctl, _("Pool %s created from %s\n"),
+                 virStoragePoolGetName(pool), from);
+        virStoragePoolFree(pool);
+    } else {
+        vshError(ctl, _("Failed to create pool from %s"), from);
+        ret = false;
+    }
+    return ret;
+}
+
+/*
+ * XML Building helper for pool-define-as and pool-create-as
+ */
+static const vshCmdOptDef opts_pool_X_as[] = {
+    {"name", VSH_OT_DATA, VSH_OFLAG_REQ, N_("name of the pool")},
+    {"print-xml", VSH_OT_BOOL, 0, N_("print XML document, but don't define/create")},
+    {"type", VSH_OT_DATA, VSH_OFLAG_REQ, N_("type of the pool")},
+    {"source-host", VSH_OT_DATA, 0, N_("source-host for underlying storage")},
+    {"source-path", VSH_OT_DATA, 0, N_("source path for underlying storage")},
+    {"source-dev", VSH_OT_DATA, 0, N_("source device for underlying storage")},
+    {"source-name", VSH_OT_DATA, 0, N_("source name for underlying storage")},
+    {"target", VSH_OT_DATA, 0, N_("target for underlying storage")},
+    {"source-format", VSH_OT_STRING, 0, N_("format for underlying storage")},
+    {NULL, 0, 0, NULL}
+};
+
+static int buildPoolXML(const vshCmd *cmd, const char **retname, char **xml) {
+
+    const char *name = NULL, *type = NULL, *srcHost = NULL, *srcPath = NULL,
+               *srcDev = NULL, *srcName = NULL, *srcFormat = NULL, *target = NULL;
+    virBuffer buf = VIR_BUFFER_INITIALIZER;
+
+    if (vshCommandOptString(cmd, "name", &name) <= 0)
+        goto cleanup;
+    if (vshCommandOptString(cmd, "type", &type) <= 0)
+        goto cleanup;
+
+    if (vshCommandOptString(cmd, "source-host", &srcHost) < 0 ||
+        vshCommandOptString(cmd, "source-path", &srcPath) < 0 ||
+        vshCommandOptString(cmd, "source-dev", &srcDev) < 0 ||
+        vshCommandOptString(cmd, "source-name", &srcName) < 0 ||
+        vshCommandOptString(cmd, "source-format", &srcFormat) < 0 ||
+        vshCommandOptString(cmd, "target", &target) < 0) {
+        vshError(NULL, "%s", _("missing argument"));
+        goto cleanup;
+    }
+
+    virBufferAsprintf(&buf, "<pool type='%s'>\n", type);
+    virBufferAsprintf(&buf, "  <name>%s</name>\n", name);
+    if (srcHost || srcPath || srcDev || srcFormat || srcName) {
+        virBufferAddLit(&buf, "  <source>\n");
+
+        if (srcHost)
+            virBufferAsprintf(&buf, "    <host name='%s'/>\n", srcHost);
+        if (srcPath)
+            virBufferAsprintf(&buf, "    <dir path='%s'/>\n", srcPath);
+        if (srcDev)
+            virBufferAsprintf(&buf, "    <device path='%s'/>\n", srcDev);
+        if (srcFormat)
+            virBufferAsprintf(&buf, "    <format type='%s'/>\n", srcFormat);
+        if (srcName)
+            virBufferAsprintf(&buf, "    <name>%s</name>\n", srcName);
+
+        virBufferAddLit(&buf, "  </source>\n");
+    }
+    if (target) {
+        virBufferAddLit(&buf, "  <target>\n");
+        virBufferAsprintf(&buf, "    <path>%s</path>\n", target);
+        virBufferAddLit(&buf, "  </target>\n");
+    }
+    virBufferAddLit(&buf, "</pool>\n");
+
+    if (virBufferError(&buf)) {
+        vshPrint(ctl, "%s", _("Failed to allocate XML buffer"));
+        return false;
+    }
+
+    *xml = virBufferContentAndReset(&buf);
+    *retname = name;
+    return true;
+
+cleanup:
+    virBufferFreeAndReset(&buf);
+    return false;
+}
+
+/*
+ * "pool-create-as" command
+ */
+static const vshCmdInfo info_pool_create_as[] = {
+    {"help", N_("create a pool from a set of args")},
+    {"desc", N_("Create a pool.")},
+    {NULL, NULL}
+};
+
+static bool
+cmdPoolCreateAs(vshControl *ctl, const vshCmd *cmd)
+{
+    virStoragePoolPtr pool;
+    const char *name;
+    char *xml;
+    bool printXML = vshCommandOptBool(cmd, "print-xml");
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (!buildPoolXML(cmd, &name, &xml))
+        return false;
+
+    if (printXML) {
+        vshPrint(ctl, "%s", xml);
+        VIR_FREE(xml);
+    } else {
+        pool = virStoragePoolCreateXML(ctl->conn, xml, 0);
+        VIR_FREE(xml);
+
+        if (pool != NULL) {
+            vshPrint(ctl, _("Pool %s created\n"), name);
+            virStoragePoolFree(pool);
+        } else {
+            vshError(ctl, _("Failed to create pool %s"), name);
+            return false;
+        }
+    }
+    return true;
+}
+
+/*
+ * "pool-define" command
+ */
+static const vshCmdInfo info_pool_define[] = {
+    {"help", N_("define (but don't start) a pool from an XML file")},
+    {"desc", N_("Define a pool.")},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_pool_define[] = {
+    {"file", VSH_OT_DATA, VSH_OFLAG_REQ, N_("file containing an XML pool description")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdPoolDefine(vshControl *ctl, const vshCmd *cmd)
+{
+    virStoragePoolPtr pool;
+    const char *from = NULL;
+    bool ret = true;
+    char *buffer;
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (vshCommandOptString(cmd, "file", &from) <= 0)
+        return false;
+
+    if (virFileReadAll(from, VIRSH_MAX_XML_FILE, &buffer) < 0)
+        return false;
+
+    pool = virStoragePoolDefineXML(ctl->conn, buffer, 0);
+    VIR_FREE(buffer);
+
+    if (pool != NULL) {
+        vshPrint(ctl, _("Pool %s defined from %s\n"),
+                 virStoragePoolGetName(pool), from);
+        virStoragePoolFree(pool);
+    } else {
+        vshError(ctl, _("Failed to define pool from %s"), from);
+        ret = false;
+    }
+    return ret;
+}
+
+/*
+ * "pool-define-as" command
+ */
+static const vshCmdInfo info_pool_define_as[] = {
+    {"help", N_("define a pool from a set of args")},
+    {"desc", N_("Define a pool.")},
+    {NULL, NULL}
+};
+
+static bool
+cmdPoolDefineAs(vshControl *ctl, const vshCmd *cmd)
+{
+    virStoragePoolPtr pool;
+    const char *name;
+    char *xml;
+    bool printXML = vshCommandOptBool(cmd, "print-xml");
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (!buildPoolXML(cmd, &name, &xml))
+        return false;
+
+    if (printXML) {
+        vshPrint(ctl, "%s", xml);
+        VIR_FREE(xml);
+    } else {
+        pool = virStoragePoolDefineXML(ctl->conn, xml, 0);
+        VIR_FREE(xml);
+
+        if (pool != NULL) {
+            vshPrint(ctl, _("Pool %s defined\n"), name);
+            virStoragePoolFree(pool);
+        } else {
+            vshError(ctl, _("Failed to define pool %s"), name);
+            return false;
+        }
+    }
+    return true;
+}
+
+/*
+ * "pool-build" command
+ */
+static const vshCmdInfo info_pool_build[] = {
+    {"help", N_("build a pool")},
+    {"desc", N_("Build a given pool.")},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_pool_build[] = {
+    {"pool", VSH_OT_DATA, VSH_OFLAG_REQ, N_("pool name or uuid")},
+    {"no-overwrite", VSH_OT_BOOL, 0, N_("do not overwrite an existing pool of this type")},
+    {"overwrite", VSH_OT_BOOL, 0, N_("overwrite any existing data")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdPoolBuild(vshControl *ctl, const vshCmd *cmd)
+{
+    virStoragePoolPtr pool;
+    bool ret = true;
+    const char *name;
+    unsigned int flags = 0;
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (!(pool = vshCommandOptPool(ctl, cmd, "pool", &name)))
+        return false;
+
+    if (vshCommandOptBool(cmd, "no-overwrite")) {
+        flags |= VIR_STORAGE_POOL_BUILD_NO_OVERWRITE;
+    }
+
+    if (vshCommandOptBool(cmd, "overwrite")) {
+        flags |= VIR_STORAGE_POOL_BUILD_OVERWRITE;
+    }
+
+    if (virStoragePoolBuild(pool, flags) == 0) {
+        vshPrint(ctl, _("Pool %s built\n"), name);
+    } else {
+        vshError(ctl, _("Failed to build pool %s"), name);
+        ret = false;
+    }
+
+    virStoragePoolFree(pool);
+
+    return ret;
+}
+
+/*
+ * "pool-destroy" command
+ */
+static const vshCmdInfo info_pool_destroy[] = {
+    {"help", N_("destroy (stop) a pool")},
+    {"desc",
+     N_("Forcefully stop a given pool. Raw data in the pool is untouched")},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_pool_destroy[] = {
+    {"pool", VSH_OT_DATA, VSH_OFLAG_REQ, N_("pool name or uuid")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdPoolDestroy(vshControl *ctl, const vshCmd *cmd)
+{
+    virStoragePoolPtr pool;
+    bool ret = true;
+    const char *name;
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (!(pool = vshCommandOptPool(ctl, cmd, "pool", &name)))
+        return false;
+
+    if (virStoragePoolDestroy(pool) == 0) {
+        vshPrint(ctl, _("Pool %s destroyed\n"), name);
+    } else {
+        vshError(ctl, _("Failed to destroy pool %s"), name);
+        ret = false;
+    }
+
+    virStoragePoolFree(pool);
+    return ret;
+}
+
+/*
+ * "pool-delete" command
+ */
+static const vshCmdInfo info_pool_delete[] = {
+    {"help", N_("delete a pool")},
+    {"desc", N_("Delete a given pool.")},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_pool_delete[] = {
+    {"pool", VSH_OT_DATA, VSH_OFLAG_REQ, N_("pool name or uuid")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdPoolDelete(vshControl *ctl, const vshCmd *cmd)
+{
+    virStoragePoolPtr pool;
+    bool ret = true;
+    const char *name;
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (!(pool = vshCommandOptPool(ctl, cmd, "pool", &name)))
+        return false;
+
+    if (virStoragePoolDelete(pool, 0) == 0) {
+        vshPrint(ctl, _("Pool %s deleted\n"), name);
+    } else {
+        vshError(ctl, _("Failed to delete pool %s"), name);
+        ret = false;
+    }
+
+    virStoragePoolFree(pool);
+    return ret;
+}
+
+/*
+ * "pool-refresh" command
+ */
+static const vshCmdInfo info_pool_refresh[] = {
+    {"help", N_("refresh a pool")},
+    {"desc", N_("Refresh a given pool.")},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_pool_refresh[] = {
+    {"pool", VSH_OT_DATA, VSH_OFLAG_REQ, N_("pool name or uuid")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdPoolRefresh(vshControl *ctl, const vshCmd *cmd)
+{
+    virStoragePoolPtr pool;
+    bool ret = true;
+    const char *name;
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (!(pool = vshCommandOptPool(ctl, cmd, "pool", &name)))
+        return false;
+
+    if (virStoragePoolRefresh(pool, 0) == 0) {
+        vshPrint(ctl, _("Pool %s refreshed\n"), name);
+    } else {
+        vshError(ctl, _("Failed to refresh pool %s"), name);
+        ret = false;
+    }
+    virStoragePoolFree(pool);
+
+    return ret;
+}
+
+/*
+ * "pool-dumpxml" command
+ */
+static const vshCmdInfo info_pool_dumpxml[] = {
+    {"help", N_("pool information in XML")},
+    {"desc", N_("Output the pool information as an XML dump to stdout.")},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_pool_dumpxml[] = {
+    {"pool", VSH_OT_DATA, VSH_OFLAG_REQ, N_("pool name or uuid")},
+    {"inactive", VSH_OT_BOOL, 0, N_("show inactive defined XML")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdPoolDumpXML(vshControl *ctl, const vshCmd *cmd)
+{
+    virStoragePoolPtr pool;
+    bool ret = true;
+    bool inactive = vshCommandOptBool(cmd, "inactive");
+    unsigned int flags = 0;
+    char *dump;
+
+    if (inactive)
+        flags |= VIR_STORAGE_XML_INACTIVE;
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (!(pool = vshCommandOptPool(ctl, cmd, "pool", NULL)))
+        return false;
+
+    dump = virStoragePoolGetXMLDesc(pool, flags);
+    if (dump != NULL) {
+        vshPrint(ctl, "%s", dump);
+        VIR_FREE(dump);
+    } else {
+        ret = false;
+    }
+
+    virStoragePoolFree(pool);
+    return ret;
+}
+
+/*
+ * "pool-list" command
+ */
+static const vshCmdInfo info_pool_list[] = {
+    {"help", N_("list pools")},
+    {"desc", N_("Returns list of pools.")},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_pool_list[] = {
+    {"inactive", VSH_OT_BOOL, 0, N_("list inactive pools")},
+    {"all", VSH_OT_BOOL, 0, N_("list inactive & active pools")},
+    {"details", VSH_OT_BOOL, 0, N_("display extended details for pools")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdPoolList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
+{
+    virStoragePoolInfo info;
+    char **poolNames = NULL;
+    int i, ret;
+    bool functionReturn;
+    int numActivePools = 0, numInactivePools = 0, numAllPools = 0;
+    size_t stringLength = 0, nameStrLength = 0;
+    size_t autostartStrLength = 0, persistStrLength = 0;
+    size_t stateStrLength = 0, capStrLength = 0;
+    size_t allocStrLength = 0, availStrLength = 0;
+    struct poolInfoText {
+        char *state;
+        char *autostart;
+        char *persistent;
+        char *capacity;
+        char *allocation;
+        char *available;
+    };
+    struct poolInfoText *poolInfoTexts = NULL;
+
+    /* Determine the options passed by the user */
+    bool all = vshCommandOptBool(cmd, "all");
+    bool details = vshCommandOptBool(cmd, "details");
+    bool inactive = vshCommandOptBool(cmd, "inactive");
+    bool active = !inactive || all;
+    inactive |= all;
+
+    /* Check the connection to libvirtd daemon is still working */
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    /* Retrieve the number of active storage pools */
+    if (active) {
+        numActivePools = virConnectNumOfStoragePools(ctl->conn);
+        if (numActivePools < 0) {
+            vshError(ctl, "%s", _("Failed to list active pools"));
+            return false;
+        }
+    }
+
+    /* Retrieve the number of inactive storage pools */
+    if (inactive) {
+        numInactivePools = virConnectNumOfDefinedStoragePools(ctl->conn);
+        if (numInactivePools < 0) {
+            vshError(ctl, "%s", _("Failed to list inactive pools"));
+            return false;
+        }
+    }
+
+    /* Determine the total number of pools to list */
+    numAllPools = numActivePools + numInactivePools;
+
+    /* Allocate memory for arrays of storage pool names and info */
+    poolNames = vshCalloc(ctl, numAllPools, sizeof(*poolNames));
+    poolInfoTexts =
+        vshCalloc(ctl, numAllPools, sizeof(*poolInfoTexts));
+
+    /* Retrieve a list of active storage pool names */
+    if (active) {
+        if (virConnectListStoragePools(ctl->conn,
+                                       poolNames, numActivePools) < 0) {
+            vshError(ctl, "%s", _("Failed to list active pools"));
+            VIR_FREE(poolInfoTexts);
+            VIR_FREE(poolNames);
+            return false;
+        }
+    }
+
+    /* Add the inactive storage pools to the end of the name list */
+    if (inactive) {
+        if (virConnectListDefinedStoragePools(ctl->conn,
+                                              &poolNames[numActivePools],
+                                              numInactivePools) < 0) {
+            vshError(ctl, "%s", _("Failed to list inactive pools"));
+            VIR_FREE(poolInfoTexts);
+            VIR_FREE(poolNames);
+            return false;
+        }
+    }
+
+    /* Sort the storage pool names */
+    qsort(poolNames, numAllPools, sizeof(*poolNames), vshNameSorter);
+
+    /* Collect the storage pool information for display */
+    for (i = 0; i < numAllPools; i++) {
+        int autostart = 0, persistent = 0;
+
+        /* Retrieve a pool object, looking it up by name */
+        virStoragePoolPtr pool = virStoragePoolLookupByName(ctl->conn,
+                                                            poolNames[i]);
+        if (!pool) {
+            VIR_FREE(poolNames[i]);
+            continue;
+        }
+
+        /* Retrieve the autostart status of the pool */
+        if (virStoragePoolGetAutostart(pool, &autostart) < 0)
+            poolInfoTexts[i].autostart = vshStrdup(ctl, _("no autostart"));
+        else
+            poolInfoTexts[i].autostart = vshStrdup(ctl, autostart ?
+                                                    _("yes") : _("no"));
+
+        /* Retrieve the persistence status of the pool */
+        if (details) {
+            persistent = virStoragePoolIsPersistent(pool);
+            vshDebug(ctl, VSH_ERR_DEBUG, "Persistent flag value: %d\n",
+                     persistent);
+            if (persistent < 0)
+                poolInfoTexts[i].persistent = vshStrdup(ctl, _("unknown"));
+            else
+                poolInfoTexts[i].persistent = vshStrdup(ctl, persistent ?
+                                                         _("yes") : _("no"));
+
+            /* Keep the length of persistent string if longest so far */
+            stringLength = strlen(poolInfoTexts[i].persistent);
+            if (stringLength > persistStrLength)
+                persistStrLength = stringLength;
+        }
+
+        /* Collect further extended information about the pool */
+        if (virStoragePoolGetInfo(pool, &info) != 0) {
+            /* Something went wrong retrieving pool info, cope with it */
+            vshError(ctl, "%s", _("Could not retrieve pool information"));
+            poolInfoTexts[i].state = vshStrdup(ctl, _("unknown"));
+            if (details) {
+                poolInfoTexts[i].capacity = vshStrdup(ctl, _("unknown"));
+                poolInfoTexts[i].allocation = vshStrdup(ctl, _("unknown"));
+                poolInfoTexts[i].available = vshStrdup(ctl, _("unknown"));
+            }
+        } else {
+            /* Decide which state string to display */
+            if (details) {
+                /* --details option was specified, we're using detailed state
+                 * strings */
+                switch (info.state) {
+                case VIR_STORAGE_POOL_INACTIVE:
+                    poolInfoTexts[i].state = vshStrdup(ctl, _("inactive"));
+                    break;
+                case VIR_STORAGE_POOL_BUILDING:
+                    poolInfoTexts[i].state = vshStrdup(ctl, _("building"));
+                    break;
+                case VIR_STORAGE_POOL_RUNNING:
+                    poolInfoTexts[i].state = vshStrdup(ctl, _("running"));
+                    break;
+                case VIR_STORAGE_POOL_DEGRADED:
+                    poolInfoTexts[i].state = vshStrdup(ctl, _("degraded"));
+                    break;
+                case VIR_STORAGE_POOL_INACCESSIBLE:
+                    poolInfoTexts[i].state = vshStrdup(ctl, _("inaccessible"));
+                    break;
+                }
+
+                /* Create the pool size related strings */
+                if (info.state == VIR_STORAGE_POOL_RUNNING ||
+                    info.state == VIR_STORAGE_POOL_DEGRADED) {
+                    double val;
+                    const char *unit;
+
+                    /* Create the capacity output string */
+                    val = prettyCapacity(info.capacity, &unit);
+                    ret = virAsprintf(&poolInfoTexts[i].capacity,
+                                      "%.2lf %s", val, unit);
+                    if (ret < 0) {
+                        /* An error occurred creating the string, return */
+                        goto asprintf_failure;
+                    }
+
+                    /* Create the allocation output string */
+                    val = prettyCapacity(info.allocation, &unit);
+                    ret = virAsprintf(&poolInfoTexts[i].allocation,
+                                      "%.2lf %s", val, unit);
+                    if (ret < 0) {
+                        /* An error occurred creating the string, return */
+                        goto asprintf_failure;
+                    }
+
+                    /* Create the available space output string */
+                    val = prettyCapacity(info.available, &unit);
+                    ret = virAsprintf(&poolInfoTexts[i].available,
+                                      "%.2lf %s", val, unit);
+                    if (ret < 0) {
+                        /* An error occurred creating the string, return */
+                        goto asprintf_failure;
+                    }
+                } else {
+                    /* Capacity related information isn't available */
+                    poolInfoTexts[i].capacity = vshStrdup(ctl, _("-"));
+                    poolInfoTexts[i].allocation = vshStrdup(ctl, _("-"));
+                    poolInfoTexts[i].available = vshStrdup(ctl, _("-"));
+                }
+
+                /* Keep the length of capacity string if longest so far */
+                stringLength = strlen(poolInfoTexts[i].capacity);
+                if (stringLength > capStrLength)
+                    capStrLength = stringLength;
+
+                /* Keep the length of allocation string if longest so far */
+                stringLength = strlen(poolInfoTexts[i].allocation);
+                if (stringLength > allocStrLength)
+                    allocStrLength = stringLength;
+
+                /* Keep the length of available string if longest so far */
+                stringLength = strlen(poolInfoTexts[i].available);
+                if (stringLength > availStrLength)
+                    availStrLength = stringLength;
+            } else {
+                /* --details option was not specified, only active/inactive
+                * state strings are used */
+                if (info.state == VIR_STORAGE_POOL_INACTIVE)
+                    poolInfoTexts[i].state = vshStrdup(ctl, _("inactive"));
+                else
+                    poolInfoTexts[i].state = vshStrdup(ctl, _("active"));
+            }
+        }
+
+        /* Keep the length of name string if longest so far */
+        stringLength = strlen(poolNames[i]);
+        if (stringLength > nameStrLength)
+            nameStrLength = stringLength;
+
+        /* Keep the length of state string if longest so far */
+        stringLength = strlen(poolInfoTexts[i].state);
+        if (stringLength > stateStrLength)
+            stateStrLength = stringLength;
+
+        /* Keep the length of autostart string if longest so far */
+        stringLength = strlen(poolInfoTexts[i].autostart);
+        if (stringLength > autostartStrLength)
+            autostartStrLength = stringLength;
+
+        /* Free the pool object */
+        virStoragePoolFree(pool);
+    }
+
+    /* If the --details option wasn't selected, we output the pool
+     * info using the fixed string format from previous versions to
+     * maintain backward compatibility.
+     */
+
+    /* Output basic info then return if --details option not selected */
+    if (!details) {
+        /* Output old style header */
+        vshPrintExtra(ctl, "%-20s %-10s %-10s\n", _("Name"), _("State"),
+                      _("Autostart"));
+        vshPrintExtra(ctl, "-----------------------------------------\n");
+
+        /* Output old style pool info */
+        for (i = 0; i < numAllPools; i++) {
+            vshPrint(ctl, "%-20s %-10s %-10s\n",
+                 poolNames[i],
+                 poolInfoTexts[i].state,
+                 poolInfoTexts[i].autostart);
+        }
+
+        /* Cleanup and return */
+        functionReturn = true;
+        goto cleanup;
+    }
+
+    /* We only get here if the --details option was selected. */
+
+    /* Use the length of name header string if it's longest */
+    stringLength = strlen(_("Name"));
+    if (stringLength > nameStrLength)
+        nameStrLength = stringLength;
+
+    /* Use the length of state header string if it's longest */
+    stringLength = strlen(_("State"));
+    if (stringLength > stateStrLength)
+        stateStrLength = stringLength;
+
+    /* Use the length of autostart header string if it's longest */
+    stringLength = strlen(_("Autostart"));
+    if (stringLength > autostartStrLength)
+        autostartStrLength = stringLength;
+
+    /* Use the length of persistent header string if it's longest */
+    stringLength = strlen(_("Persistent"));
+    if (stringLength > persistStrLength)
+        persistStrLength = stringLength;
+
+    /* Use the length of capacity header string if it's longest */
+    stringLength = strlen(_("Capacity"));
+    if (stringLength > capStrLength)
+        capStrLength = stringLength;
+
+    /* Use the length of allocation header string if it's longest */
+    stringLength = strlen(_("Allocation"));
+    if (stringLength > allocStrLength)
+        allocStrLength = stringLength;
+
+    /* Use the length of available header string if it's longest */
+    stringLength = strlen(_("Available"));
+    if (stringLength > availStrLength)
+        availStrLength = stringLength;
+
+    /* Display the string lengths for debugging. */
+    vshDebug(ctl, VSH_ERR_DEBUG, "Longest name string = %lu chars\n",
+             (unsigned long) nameStrLength);
+    vshDebug(ctl, VSH_ERR_DEBUG, "Longest state string = %lu chars\n",
+             (unsigned long) stateStrLength);
+    vshDebug(ctl, VSH_ERR_DEBUG, "Longest autostart string = %lu chars\n",
+             (unsigned long) autostartStrLength);
+    vshDebug(ctl, VSH_ERR_DEBUG, "Longest persistent string = %lu chars\n",
+             (unsigned long) persistStrLength);
+    vshDebug(ctl, VSH_ERR_DEBUG, "Longest capacity string = %lu chars\n",
+             (unsigned long) capStrLength);
+    vshDebug(ctl, VSH_ERR_DEBUG, "Longest allocation string = %lu chars\n",
+             (unsigned long) allocStrLength);
+    vshDebug(ctl, VSH_ERR_DEBUG, "Longest available string = %lu chars\n",
+             (unsigned long) availStrLength);
+
+    /* Create the output template.  Each column is sized according to
+     * the longest string.
+     */
+    char *outputStr;
+    ret = virAsprintf(&outputStr,
+              "%%-%lus  %%-%lus  %%-%lus  %%-%lus  %%%lus  %%%lus  %%%lus\n",
+              (unsigned long) nameStrLength,
+              (unsigned long) stateStrLength,
+              (unsigned long) autostartStrLength,
+              (unsigned long) persistStrLength,
+              (unsigned long) capStrLength,
+              (unsigned long) allocStrLength,
+              (unsigned long) availStrLength);
+    if (ret < 0) {
+        /* An error occurred creating the string, return */
+        goto asprintf_failure;
+    }
+
+    /* Display the header */
+    vshPrint(ctl, outputStr, _("Name"), _("State"), _("Autostart"),
+             _("Persistent"), _("Capacity"), _("Allocation"), _("Available"));
+    for (i = nameStrLength + stateStrLength + autostartStrLength
+                           + persistStrLength + capStrLength
+                           + allocStrLength + availStrLength
+                           + 12; i > 0; i--)
+        vshPrintExtra(ctl, "-");
+    vshPrintExtra(ctl, "\n");
+
+    /* Display the pool info rows */
+    for (i = 0; i < numAllPools; i++) {
+        vshPrint(ctl, outputStr,
+                 poolNames[i],
+                 poolInfoTexts[i].state,
+                 poolInfoTexts[i].autostart,
+                 poolInfoTexts[i].persistent,
+                 poolInfoTexts[i].capacity,
+                 poolInfoTexts[i].allocation,
+                 poolInfoTexts[i].available);
+    }
+
+    /* Cleanup and return */
+    functionReturn = true;
+    goto cleanup;
+
+asprintf_failure:
+
+    /* Display an appropriate error message then cleanup and return */
+    switch (errno) {
+    case ENOMEM:
+        /* Couldn't allocate memory */
+        vshError(ctl, "%s", _("Out of memory"));
+        break;
+    default:
+        /* Some other error */
+        vshError(ctl, _("virAsprintf failed (errno %d)"), errno);
+    }
+    functionReturn = false;
+
+cleanup:
+
+    /* Safely free the memory allocated in this function */
+    for (i = 0; i < numAllPools; i++) {
+        /* Cleanup the memory for one pool info structure */
+        VIR_FREE(poolInfoTexts[i].state);
+        VIR_FREE(poolInfoTexts[i].autostart);
+        VIR_FREE(poolInfoTexts[i].persistent);
+        VIR_FREE(poolInfoTexts[i].capacity);
+        VIR_FREE(poolInfoTexts[i].allocation);
+        VIR_FREE(poolInfoTexts[i].available);
+        VIR_FREE(poolNames[i]);
+    }
+
+    /* Cleanup the memory for the initial arrays*/
+    VIR_FREE(poolInfoTexts);
+    VIR_FREE(poolNames);
+
+    /* Return the desired value */
+    return functionReturn;
+}
+
+/*
+ * "find-storage-pool-sources-as" command
+ */
+static const vshCmdInfo info_find_storage_pool_sources_as[] = {
+    {"help", N_("find potential storage pool sources")},
+    {"desc", N_("Returns XML <sources> document.")},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_find_storage_pool_sources_as[] = {
+    {"type", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("type of storage pool sources to find")},
+    {"host", VSH_OT_DATA, VSH_OFLAG_NONE, N_("optional host to query")},
+    {"port", VSH_OT_DATA, VSH_OFLAG_NONE, N_("optional port to query")},
+    {"initiator", VSH_OT_DATA, VSH_OFLAG_NONE, N_("optional initiator IQN to use for query")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdPoolDiscoverSourcesAs(vshControl * ctl, const vshCmd * cmd ATTRIBUTE_UNUSED)
+{
+    const char *type = NULL, *host = NULL;
+    char *srcSpec = NULL;
+    char *srcList;
+    const char *initiator = NULL;
+
+    if (vshCommandOptString(cmd, "type", &type) <= 0 ||
+        vshCommandOptString(cmd, "host", &host) < 0 ||
+        vshCommandOptString(cmd, "initiator", &initiator) < 0) {
+        vshError(ctl,"%s", _("missing argument"));
+        return false;
+    }
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (host) {
+        const char *port = NULL;
+        virBuffer buf = VIR_BUFFER_INITIALIZER;
+
+        if (vshCommandOptString(cmd, "port", &port) < 0) {
+            vshError(ctl, "%s", _("missing argument"));
+            virBufferFreeAndReset(&buf);
+            return false;
+        }
+        virBufferAddLit(&buf, "<source>\n");
+        virBufferAsprintf(&buf, "  <host name='%s'", host);
+        if (port)
+            virBufferAsprintf(&buf, " port='%s'", port);
+        virBufferAddLit(&buf, "/>\n");
+        if (initiator) {
+            virBufferAddLit(&buf, "  <initiator>\n");
+            virBufferAsprintf(&buf, "    <iqn name='%s'/>\n", initiator);
+            virBufferAddLit(&buf, "  </initiator>\n");
+        }
+        virBufferAddLit(&buf, "</source>\n");
+        if (virBufferError(&buf)) {
+            vshError(ctl, "%s", _("Out of memory"));
+            return false;
+        }
+        srcSpec = virBufferContentAndReset(&buf);
+    }
+
+    srcList = virConnectFindStoragePoolSources(ctl->conn, type, srcSpec, 0);
+    VIR_FREE(srcSpec);
+    if (srcList == NULL) {
+        vshError(ctl, _("Failed to find any %s pool sources"), type);
+        return false;
+    }
+    vshPrint(ctl, "%s", srcList);
+    VIR_FREE(srcList);
+
+    return true;
+}
+
+/*
+ * "find-storage-pool-sources" command
+ */
+static const vshCmdInfo info_find_storage_pool_sources[] = {
+    {"help", N_("discover potential storage pool sources")},
+    {"desc", N_("Returns XML <sources> document.")},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_find_storage_pool_sources[] = {
+    {"type", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("type of storage pool sources to discover")},
+    {"srcSpec", VSH_OT_DATA, VSH_OFLAG_NONE,
+     N_("optional file of source xml to query for pools")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdPoolDiscoverSources(vshControl * ctl, const vshCmd * cmd ATTRIBUTE_UNUSED)
+{
+    const char *type = NULL, *srcSpecFile = NULL;
+    char *srcSpec = NULL, *srcList;
+
+    if (vshCommandOptString(cmd, "type", &type) <= 0)
+        return false;
+
+    if (vshCommandOptString(cmd, "srcSpec", &srcSpecFile) < 0) {
+        vshError(ctl, "%s", _("missing option"));
+        return false;
+    }
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (srcSpecFile && virFileReadAll(srcSpecFile, VIRSH_MAX_XML_FILE, &srcSpec) < 0)
+        return false;
+
+    srcList = virConnectFindStoragePoolSources(ctl->conn, type, srcSpec, 0);
+    VIR_FREE(srcSpec);
+    if (srcList == NULL) {
+        vshError(ctl, _("Failed to find any %s pool sources"), type);
+        return false;
+    }
+    vshPrint(ctl, "%s", srcList);
+    VIR_FREE(srcList);
+
+    return true;
+}
+
+/*
+ * "pool-info" command
+ */
+static const vshCmdInfo info_pool_info[] = {
+    {"help", N_("storage pool information")},
+    {"desc", N_("Returns basic information about the storage pool.")},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_pool_info[] = {
+    {"pool", VSH_OT_DATA, VSH_OFLAG_REQ, N_("pool name or uuid")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdPoolInfo(vshControl *ctl, const vshCmd *cmd)
+{
+    virStoragePoolInfo info;
+    virStoragePoolPtr pool;
+    int autostart = 0;
+    int persistent = 0;
+    bool ret = true;
+    char uuid[VIR_UUID_STRING_BUFLEN];
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (!(pool = vshCommandOptPool(ctl, cmd, "pool", NULL)))
+        return false;
+
+    vshPrint(ctl, "%-15s %s\n", _("Name:"), virStoragePoolGetName(pool));
+
+    if (virStoragePoolGetUUIDString(pool, &uuid[0])==0)
+        vshPrint(ctl, "%-15s %s\n", _("UUID:"), uuid);
+
+    if (virStoragePoolGetInfo(pool, &info) == 0) {
+        double val;
+        const char *unit;
+        switch (info.state) {
+        case VIR_STORAGE_POOL_INACTIVE:
+            vshPrint(ctl, "%-15s %s\n", _("State:"),
+                     _("inactive"));
+            break;
+        case VIR_STORAGE_POOL_BUILDING:
+            vshPrint(ctl, "%-15s %s\n", _("State:"),
+                     _("building"));
+            break;
+        case VIR_STORAGE_POOL_RUNNING:
+            vshPrint(ctl, "%-15s %s\n", _("State:"),
+                     _("running"));
+            break;
+        case VIR_STORAGE_POOL_DEGRADED:
+            vshPrint(ctl, "%-15s %s\n", _("State:"),
+                     _("degraded"));
+            break;
+        case VIR_STORAGE_POOL_INACCESSIBLE:
+            vshPrint(ctl, "%-15s %s\n", _("State:"),
+                     _("inaccessible"));
+            break;
+        }
+
+        /* Check and display whether the pool is persistent or not */
+        persistent = virStoragePoolIsPersistent(pool);
+        vshDebug(ctl, VSH_ERR_DEBUG, "Pool persistent flag value: %d\n",
+                 persistent);
+        if (persistent < 0)
+            vshPrint(ctl, "%-15s %s\n", _("Persistent:"),  _("unknown"));
+        else
+            vshPrint(ctl, "%-15s %s\n", _("Persistent:"), persistent ? _("yes") : _("no"));
+
+        /* Check and display whether the pool is autostarted or not */
+        virStoragePoolGetAutostart(pool, &autostart);
+        vshDebug(ctl, VSH_ERR_DEBUG, "Pool autostart flag value: %d\n",
+                 autostart);
+        if (autostart < 0)
+            vshPrint(ctl, "%-15s %s\n", _("Autostart:"), _("no autostart"));
+        else
+            vshPrint(ctl, "%-15s %s\n", _("Autostart:"), autostart ? _("yes") : _("no"));
+
+        if (info.state == VIR_STORAGE_POOL_RUNNING ||
+            info.state == VIR_STORAGE_POOL_DEGRADED) {
+            val = prettyCapacity(info.capacity, &unit);
+            vshPrint(ctl, "%-15s %2.2lf %s\n", _("Capacity:"), val, unit);
+
+            val = prettyCapacity(info.allocation, &unit);
+            vshPrint(ctl, "%-15s %2.2lf %s\n", _("Allocation:"), val, unit);
+
+            val = prettyCapacity(info.available, &unit);
+            vshPrint(ctl, "%-15s %2.2lf %s\n", _("Available:"), val, unit);
+        }
+    } else {
+        ret = false;
+    }
+
+    virStoragePoolFree(pool);
+    return ret;
+}
+
+/*
+ * "pool-name" command
+ */
+static const vshCmdInfo info_pool_name[] = {
+    {"help", N_("convert a pool UUID to pool name")},
+    {"desc", ""},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_pool_name[] = {
+    {"pool", VSH_OT_DATA, VSH_OFLAG_REQ, N_("pool uuid")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdPoolName(vshControl *ctl, const vshCmd *cmd)
+{
+    virStoragePoolPtr pool;
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+    if (!(pool = vshCommandOptPoolBy(ctl, cmd, "pool", NULL,
+                                           VSH_BYUUID)))
+        return false;
+
+    vshPrint(ctl, "%s\n", virStoragePoolGetName(pool));
+    virStoragePoolFree(pool);
+    return true;
+}
+
+/*
+ * "pool-start" command
+ */
+static const vshCmdInfo info_pool_start[] = {
+    {"help", N_("start a (previously defined) inactive pool")},
+    {"desc", N_("Start a pool.")},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_pool_start[] = {
+    {"pool", VSH_OT_DATA, VSH_OFLAG_REQ, N_("name or uuid of the inactive pool")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdPoolStart(vshControl *ctl, const vshCmd *cmd)
+{
+    virStoragePoolPtr pool;
+    bool ret = true;
+    const char *name = NULL;
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (!(pool = vshCommandOptPool(ctl, cmd, "pool", &name)))
+         return false;
+
+    if (virStoragePoolCreate(pool, 0) == 0) {
+        vshPrint(ctl, _("Pool %s started\n"), name);
+    } else {
+        vshError(ctl, _("Failed to start pool %s"), name);
+        ret = false;
+    }
+
+    virStoragePoolFree(pool);
+    return ret;
+}
+
+/*
+ * "pool-undefine" command
+ */
+static const vshCmdInfo info_pool_undefine[] = {
+    {"help", N_("undefine an inactive pool")},
+    {"desc", N_("Undefine the configuration for an inactive pool.")},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_pool_undefine[] = {
+    {"pool", VSH_OT_DATA, VSH_OFLAG_REQ, N_("pool name or uuid")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdPoolUndefine(vshControl *ctl, const vshCmd *cmd)
+{
+    virStoragePoolPtr pool;
+    bool ret = true;
+    const char *name;
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (!(pool = vshCommandOptPool(ctl, cmd, "pool", &name)))
+        return false;
+
+    if (virStoragePoolUndefine(pool) == 0) {
+        vshPrint(ctl, _("Pool %s has been undefined\n"), name);
+    } else {
+        vshError(ctl, _("Failed to undefine pool %s"), name);
+        ret = false;
+    }
+
+    virStoragePoolFree(pool);
+    return ret;
+}
+
+/*
+ * "pool-uuid" command
+ */
+static const vshCmdInfo info_pool_uuid[] = {
+    {"help", N_("convert a pool name to pool UUID")},
+    {"desc", ""},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_pool_uuid[] = {
+    {"pool", VSH_OT_DATA, VSH_OFLAG_REQ, N_("pool name")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdPoolUuid(vshControl *ctl, const vshCmd *cmd)
+{
+    virStoragePoolPtr pool;
+    char uuid[VIR_UUID_STRING_BUFLEN];
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (!(pool = vshCommandOptPoolBy(ctl, cmd, "pool", NULL,
+                                           VSH_BYNAME)))
+        return false;
+
+    if (virStoragePoolGetUUIDString(pool, uuid) != -1)
+        vshPrint(ctl, "%s\n", uuid);
+    else
+        vshError(ctl, "%s", _("failed to get pool UUID"));
+
+    virStoragePoolFree(pool);
+    return true;
+}
+
+/*
+ * "pool-edit" command
+ */
+static const vshCmdInfo info_pool_edit[] = {
+    {"help", N_("edit XML configuration for a storage pool")},
+    {"desc", N_("Edit the XML configuration for a storage pool.")},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_pool_edit[] = {
+    {"pool", VSH_OT_DATA, VSH_OFLAG_REQ, N_("pool name or uuid")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdPoolEdit(vshControl *ctl, const vshCmd *cmd)
+{
+    bool ret = false;
+    virStoragePoolPtr pool = NULL;
+    virStoragePoolPtr pool_edited = NULL;
+    unsigned int flags = VIR_STORAGE_XML_INACTIVE;
+    char *tmp_desc = NULL;
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        goto cleanup;
+
+    pool = vshCommandOptPool(ctl, cmd, "pool", NULL);
+    if (pool == NULL)
+        goto cleanup;
+
+    /* Some old daemons don't support _INACTIVE flag */
+    if (!(tmp_desc = virStoragePoolGetXMLDesc(pool, flags))) {
+        if (last_error->code == VIR_ERR_INVALID_ARG) {
+            flags &= ~VIR_STORAGE_XML_INACTIVE;
+            virFreeError(last_error);
+            last_error = NULL;
+        } else {
+            goto cleanup;
+        }
+    } else {
+        VIR_FREE(tmp_desc);
+    }
+
+#define EDIT_GET_XML virStoragePoolGetXMLDesc(pool, flags)
+#define EDIT_NOT_CHANGED \
+    vshPrint(ctl, _("Pool %s XML configuration not changed.\n"),    \
+             virStoragePoolGetName(pool));                          \
+    ret = true; goto edit_cleanup;
+#define EDIT_DEFINE \
+    (pool_edited = virStoragePoolDefineXML(ctl->conn, doc_edited, 0))
+#define EDIT_FREE \
+    if (pool_edited)    \
+        virStoragePoolFree(pool_edited);
+#include "virsh-edit.c"
+
+    vshPrint(ctl, _("Pool %s XML configuration edited.\n"),
+             virStoragePoolGetName(pool_edited));
+
+    ret = true;
+
+ cleanup:
+    if (pool)
+        virStoragePoolFree(pool);
+    if (pool_edited)
+        virStoragePoolFree(pool_edited);
+
+    return ret;
+}
diff --git a/tools/virsh.c b/tools/virsh.c
index ac8ad09..7a30871 100644
--- a/tools/virsh.c
+++ b/tools/virsh.c
@@ -364,14 +364,6 @@ static virInterfacePtr vshCommandOptInterfaceBy(vshControl *ctl, const vshCmd *c
     vshCommandOptInterfaceBy(_ctl, _cmd, NULL, _name,                \
                              VSH_BYMAC|VSH_BYNAME)
 
-static virStoragePoolPtr vshCommandOptPoolBy(vshControl *ctl, const vshCmd *cmd,
-                            const char *optname, const char **name, int flag);
-
-/* default is lookup by Name and UUID */
-#define vshCommandOptPool(_ctl, _cmd, _optname, _name)           \
-    vshCommandOptPoolBy(_ctl, _cmd, _optname, _name,             \
-                           VSH_BYUUID|VSH_BYNAME)
-
 static virSecretPtr vshCommandOptSecret(vshControl *ctl, const vshCmd *cmd,
                                         const char **name);
 
@@ -2863,1548 +2855,250 @@ static const vshCmdInfo info_nwfilter_dumpxml[] = {
     {NULL, NULL}
 };
 
-static const vshCmdOptDef opts_nwfilter_dumpxml[] = {
-    {"nwfilter", VSH_OT_DATA, VSH_OFLAG_REQ, N_("network filter name or uuid")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdNWFilterDumpXML(vshControl *ctl, const vshCmd *cmd)
-{
-    virNWFilterPtr nwfilter;
-    bool ret = true;
-    char *dump;
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    if (!(nwfilter = vshCommandOptNWFilter(ctl, cmd, NULL)))
-        return false;
-
-    dump = virNWFilterGetXMLDesc(nwfilter, 0);
-    if (dump != NULL) {
-        vshPrint(ctl, "%s", dump);
-        VIR_FREE(dump);
-    } else {
-        ret = false;
-    }
-
-    virNWFilterFree(nwfilter);
-    return ret;
-}
-
-/*
- * "nwfilter-list" command
- */
-static const vshCmdInfo info_nwfilter_list[] = {
-    {"help", N_("list network filters")},
-    {"desc", N_("Returns list of network filters.")},
-    {NULL, NULL}
-};
-
-static const vshCmdOptDef opts_nwfilter_list[] = {
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdNWFilterList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
-{
-    int numfilters, i;
-    char **names;
-    char uuid[VIR_UUID_STRING_BUFLEN];
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    numfilters = virConnectNumOfNWFilters(ctl->conn);
-    if (numfilters < 0) {
-        vshError(ctl, "%s", _("Failed to list network filters"));
-        return false;
-    }
-
-    names = vshMalloc(ctl, sizeof(char *) * numfilters);
-
-    if ((numfilters = virConnectListNWFilters(ctl->conn, names,
-                                              numfilters)) < 0) {
-        vshError(ctl, "%s", _("Failed to list network filters"));
-        VIR_FREE(names);
-        return false;
-    }
-
-    qsort(&names[0], numfilters, sizeof(char *), vshNameSorter);
-
-    vshPrintExtra(ctl, "%-36s  %-20s \n", _("UUID"), _("Name"));
-    vshPrintExtra(ctl,
-       "----------------------------------------------------------------\n");
-
-    for (i = 0; i < numfilters; i++) {
-        virNWFilterPtr nwfilter =
-            virNWFilterLookupByName(ctl->conn, names[i]);
-
-        /* this kind of work with networks is not atomic operation */
-        if (!nwfilter) {
-            VIR_FREE(names[i]);
-            continue;
-        }
-
-        virNWFilterGetUUIDString(nwfilter, uuid);
-        vshPrint(ctl, "%-36s  %-20s\n",
-                 uuid,
-                 virNWFilterGetName(nwfilter));
-        virNWFilterFree(nwfilter);
-        VIR_FREE(names[i]);
-    }
-
-    VIR_FREE(names);
-    return true;
-}
-
-
-/*
- * "nwfilter-edit" command
- */
-static const vshCmdInfo info_nwfilter_edit[] = {
-    {"help", N_("edit XML configuration for a network filter")},
-    {"desc", N_("Edit the XML configuration for a network filter.")},
-    {NULL, NULL}
-};
-
-static const vshCmdOptDef opts_nwfilter_edit[] = {
-    {"nwfilter", VSH_OT_DATA, VSH_OFLAG_REQ, N_("network filter name or uuid")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdNWFilterEdit(vshControl *ctl, const vshCmd *cmd)
-{
-    bool ret = false;
-    virNWFilterPtr nwfilter = NULL;
-    virNWFilterPtr nwfilter_edited = NULL;
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        goto cleanup;
-
-    nwfilter = vshCommandOptNWFilter(ctl, cmd, NULL);
-    if (nwfilter == NULL)
-        goto cleanup;
-
-#define EDIT_GET_XML virNWFilterGetXMLDesc(nwfilter, 0)
-#define EDIT_NOT_CHANGED \
-    vshPrint(ctl, _("Network filter %s XML "            \
-                    "configuration not changed.\n"),    \
-             virNWFilterGetName(nwfilter));             \
-    ret = true; goto edit_cleanup;
-#define EDIT_DEFINE \
-    (nwfilter_edited = virNWFilterDefineXML(ctl->conn, doc_edited))
-#define EDIT_FREE \
-    if (nwfilter_edited)    \
-        virNWFilterFree(nwfilter);
-#include "virsh-edit.c"
-
-    vshPrint(ctl, _("Network filter %s XML configuration edited.\n"),
-             virNWFilterGetName(nwfilter_edited));
-
-    ret = true;
-
-cleanup:
-    if (nwfilter)
-        virNWFilterFree(nwfilter);
-    if (nwfilter_edited)
-        virNWFilterFree(nwfilter_edited);
-
-    return ret;
-}
-
-
-/**************************************************************************/
-/*
- * "pool-autostart" command
- */
-static const vshCmdInfo info_pool_autostart[] = {
-    {"help", N_("autostart a pool")},
-    {"desc",
-     N_("Configure a pool to be automatically started at boot.")},
-    {NULL, NULL}
-};
-
-static const vshCmdOptDef opts_pool_autostart[] = {
-    {"pool",  VSH_OT_DATA, VSH_OFLAG_REQ, N_("pool name or uuid")},
-    {"disable", VSH_OT_BOOL, 0, N_("disable autostarting")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdPoolAutostart(vshControl *ctl, const vshCmd *cmd)
-{
-    virStoragePoolPtr pool;
-    const char *name;
-    int autostart;
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    if (!(pool = vshCommandOptPool(ctl, cmd, "pool", &name)))
-        return false;
-
-    autostart = !vshCommandOptBool(cmd, "disable");
-
-    if (virStoragePoolSetAutostart(pool, autostart) < 0) {
-        if (autostart)
-            vshError(ctl, _("failed to mark pool %s as autostarted"), name);
-        else
-            vshError(ctl, _("failed to unmark pool %s as autostarted"), name);
-        virStoragePoolFree(pool);
-        return false;
-    }
-
-    if (autostart)
-        vshPrint(ctl, _("Pool %s marked as autostarted\n"), name);
-    else
-        vshPrint(ctl, _("Pool %s unmarked as autostarted\n"), name);
-
-    virStoragePoolFree(pool);
-    return true;
-}
-
-/*
- * "pool-create" command
- */
-static const vshCmdInfo info_pool_create[] = {
-    {"help", N_("create a pool from an XML file")},
-    {"desc", N_("Create a pool.")},
-    {NULL, NULL}
-};
-
-static const vshCmdOptDef opts_pool_create[] = {
-    {"file", VSH_OT_DATA, VSH_OFLAG_REQ,
-     N_("file containing an XML pool description")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdPoolCreate(vshControl *ctl, const vshCmd *cmd)
-{
-    virStoragePoolPtr pool;
-    const char *from = NULL;
-    bool ret = true;
-    char *buffer;
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    if (vshCommandOptString(cmd, "file", &from) <= 0)
-        return false;
-
-    if (virFileReadAll(from, VIRSH_MAX_XML_FILE, &buffer) < 0)
-        return false;
-
-    pool = virStoragePoolCreateXML(ctl->conn, buffer, 0);
-    VIR_FREE(buffer);
-
-    if (pool != NULL) {
-        vshPrint(ctl, _("Pool %s created from %s\n"),
-                 virStoragePoolGetName(pool), from);
-        virStoragePoolFree(pool);
-    } else {
-        vshError(ctl, _("Failed to create pool from %s"), from);
-        ret = false;
-    }
-    return ret;
-}
-
-
-/*
- * "nodedev-create" command
- */
-static const vshCmdInfo info_node_device_create[] = {
-    {"help", N_("create a device defined "
-                          "by an XML file on the node")},
-    {"desc", N_("Create a device on the node.  Note that this "
-                          "command creates devices on the physical host "
-                          "that can then be assigned to a virtual machine.")},
-    {NULL, NULL}
-};
-
-static const vshCmdOptDef opts_node_device_create[] = {
-    {"file", VSH_OT_DATA, VSH_OFLAG_REQ,
-     N_("file containing an XML description of the device")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdNodeDeviceCreate(vshControl *ctl, const vshCmd *cmd)
-{
-    virNodeDevicePtr dev = NULL;
-    const char *from = NULL;
-    bool ret = true;
-    char *buffer;
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    if (vshCommandOptString(cmd, "file", &from) <= 0)
-        return false;
-
-    if (virFileReadAll(from, VIRSH_MAX_XML_FILE, &buffer) < 0)
-        return false;
-
-    dev = virNodeDeviceCreateXML(ctl->conn, buffer, 0);
-    VIR_FREE(buffer);
-
-    if (dev != NULL) {
-        vshPrint(ctl, _("Node device %s created from %s\n"),
-                 virNodeDeviceGetName(dev), from);
-        virNodeDeviceFree(dev);
-    } else {
-        vshError(ctl, _("Failed to create node device from %s"), from);
-        ret = false;
-    }
-
-    return ret;
-}
-
-
-/*
- * "nodedev-destroy" command
- */
-static const vshCmdInfo info_node_device_destroy[] = {
-    {"help", N_("destroy (stop) a device on the node")},
-    {"desc", N_("Destroy a device on the node.  Note that this "
-                "command destroys devices on the physical host")},
-    {NULL, NULL}
-};
-
-static const vshCmdOptDef opts_node_device_destroy[] = {
-    {"name", VSH_OT_DATA, VSH_OFLAG_REQ,
-     N_("name of the device to be destroyed")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdNodeDeviceDestroy(vshControl *ctl, const vshCmd *cmd)
-{
-    virNodeDevicePtr dev = NULL;
-    bool ret = true;
-    const char *name = NULL;
-
-    if (!vshConnectionUsability(ctl, ctl->conn)) {
-        return false;
-    }
-
-    if (vshCommandOptString(cmd, "name", &name) <= 0)
-        return false;
-
-    dev = virNodeDeviceLookupByName(ctl->conn, name);
-
-    if (virNodeDeviceDestroy(dev) == 0) {
-        vshPrint(ctl, _("Destroyed node device '%s'\n"), name);
-    } else {
-        vshError(ctl, _("Failed to destroy node device '%s'"), name);
-        ret = false;
-    }
-
-    virNodeDeviceFree(dev);
-    return ret;
-}
-
-
-/*
- * XML Building helper for pool-define-as and pool-create-as
- */
-static const vshCmdOptDef opts_pool_X_as[] = {
-    {"name", VSH_OT_DATA, VSH_OFLAG_REQ, N_("name of the pool")},
-    {"print-xml", VSH_OT_BOOL, 0, N_("print XML document, but don't define/create")},
-    {"type", VSH_OT_DATA, VSH_OFLAG_REQ, N_("type of the pool")},
-    {"source-host", VSH_OT_DATA, 0, N_("source-host for underlying storage")},
-    {"source-path", VSH_OT_DATA, 0, N_("source path for underlying storage")},
-    {"source-dev", VSH_OT_DATA, 0, N_("source device for underlying storage")},
-    {"source-name", VSH_OT_DATA, 0, N_("source name for underlying storage")},
-    {"target", VSH_OT_DATA, 0, N_("target for underlying storage")},
-    {"source-format", VSH_OT_STRING, 0, N_("format for underlying storage")},
-    {NULL, 0, 0, NULL}
-};
-
-static int buildPoolXML(const vshCmd *cmd, const char **retname, char **xml) {
-
-    const char *name = NULL, *type = NULL, *srcHost = NULL, *srcPath = NULL,
-               *srcDev = NULL, *srcName = NULL, *srcFormat = NULL, *target = NULL;
-    virBuffer buf = VIR_BUFFER_INITIALIZER;
-
-    if (vshCommandOptString(cmd, "name", &name) <= 0)
-        goto cleanup;
-    if (vshCommandOptString(cmd, "type", &type) <= 0)
-        goto cleanup;
-
-    if (vshCommandOptString(cmd, "source-host", &srcHost) < 0 ||
-        vshCommandOptString(cmd, "source-path", &srcPath) < 0 ||
-        vshCommandOptString(cmd, "source-dev", &srcDev) < 0 ||
-        vshCommandOptString(cmd, "source-name", &srcName) < 0 ||
-        vshCommandOptString(cmd, "source-format", &srcFormat) < 0 ||
-        vshCommandOptString(cmd, "target", &target) < 0) {
-        vshError(NULL, "%s", _("missing argument"));
-        goto cleanup;
-    }
-
-    virBufferAsprintf(&buf, "<pool type='%s'>\n", type);
-    virBufferAsprintf(&buf, "  <name>%s</name>\n", name);
-    if (srcHost || srcPath || srcDev || srcFormat || srcName) {
-        virBufferAddLit(&buf, "  <source>\n");
-
-        if (srcHost)
-            virBufferAsprintf(&buf, "    <host name='%s'/>\n", srcHost);
-        if (srcPath)
-            virBufferAsprintf(&buf, "    <dir path='%s'/>\n", srcPath);
-        if (srcDev)
-            virBufferAsprintf(&buf, "    <device path='%s'/>\n", srcDev);
-        if (srcFormat)
-            virBufferAsprintf(&buf, "    <format type='%s'/>\n", srcFormat);
-        if (srcName)
-            virBufferAsprintf(&buf, "    <name>%s</name>\n", srcName);
-
-        virBufferAddLit(&buf, "  </source>\n");
-    }
-    if (target) {
-        virBufferAddLit(&buf, "  <target>\n");
-        virBufferAsprintf(&buf, "    <path>%s</path>\n", target);
-        virBufferAddLit(&buf, "  </target>\n");
-    }
-    virBufferAddLit(&buf, "</pool>\n");
-
-    if (virBufferError(&buf)) {
-        vshPrint(ctl, "%s", _("Failed to allocate XML buffer"));
-        return false;
-    }
-
-    *xml = virBufferContentAndReset(&buf);
-    *retname = name;
-    return true;
-
-cleanup:
-    virBufferFreeAndReset(&buf);
-    return false;
-}
-
-/*
- * "pool-create-as" command
- */
-static const vshCmdInfo info_pool_create_as[] = {
-    {"help", N_("create a pool from a set of args")},
-    {"desc", N_("Create a pool.")},
-    {NULL, NULL}
-};
-
-static bool
-cmdPoolCreateAs(vshControl *ctl, const vshCmd *cmd)
-{
-    virStoragePoolPtr pool;
-    const char *name;
-    char *xml;
-    bool printXML = vshCommandOptBool(cmd, "print-xml");
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    if (!buildPoolXML(cmd, &name, &xml))
-        return false;
-
-    if (printXML) {
-        vshPrint(ctl, "%s", xml);
-        VIR_FREE(xml);
-    } else {
-        pool = virStoragePoolCreateXML(ctl->conn, xml, 0);
-        VIR_FREE(xml);
-
-        if (pool != NULL) {
-            vshPrint(ctl, _("Pool %s created\n"), name);
-            virStoragePoolFree(pool);
-        } else {
-            vshError(ctl, _("Failed to create pool %s"), name);
-            return false;
-        }
-    }
-    return true;
-}
-
-
-/*
- * "pool-define" command
- */
-static const vshCmdInfo info_pool_define[] = {
-    {"help", N_("define (but don't start) a pool from an XML file")},
-    {"desc", N_("Define a pool.")},
-    {NULL, NULL}
-};
-
-static const vshCmdOptDef opts_pool_define[] = {
-    {"file", VSH_OT_DATA, VSH_OFLAG_REQ, N_("file containing an XML pool description")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdPoolDefine(vshControl *ctl, const vshCmd *cmd)
-{
-    virStoragePoolPtr pool;
-    const char *from = NULL;
-    bool ret = true;
-    char *buffer;
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    if (vshCommandOptString(cmd, "file", &from) <= 0)
-        return false;
-
-    if (virFileReadAll(from, VIRSH_MAX_XML_FILE, &buffer) < 0)
-        return false;
-
-    pool = virStoragePoolDefineXML(ctl->conn, buffer, 0);
-    VIR_FREE(buffer);
-
-    if (pool != NULL) {
-        vshPrint(ctl, _("Pool %s defined from %s\n"),
-                 virStoragePoolGetName(pool), from);
-        virStoragePoolFree(pool);
-    } else {
-        vshError(ctl, _("Failed to define pool from %s"), from);
-        ret = false;
-    }
-    return ret;
-}
-
-
-/*
- * "pool-define-as" command
- */
-static const vshCmdInfo info_pool_define_as[] = {
-    {"help", N_("define a pool from a set of args")},
-    {"desc", N_("Define a pool.")},
-    {NULL, NULL}
-};
-
-static bool
-cmdPoolDefineAs(vshControl *ctl, const vshCmd *cmd)
-{
-    virStoragePoolPtr pool;
-    const char *name;
-    char *xml;
-    bool printXML = vshCommandOptBool(cmd, "print-xml");
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    if (!buildPoolXML(cmd, &name, &xml))
-        return false;
-
-    if (printXML) {
-        vshPrint(ctl, "%s", xml);
-        VIR_FREE(xml);
-    } else {
-        pool = virStoragePoolDefineXML(ctl->conn, xml, 0);
-        VIR_FREE(xml);
-
-        if (pool != NULL) {
-            vshPrint(ctl, _("Pool %s defined\n"), name);
-            virStoragePoolFree(pool);
-        } else {
-            vshError(ctl, _("Failed to define pool %s"), name);
-            return false;
-        }
-    }
-    return true;
-}
-
-
-/*
- * "pool-build" command
- */
-static const vshCmdInfo info_pool_build[] = {
-    {"help", N_("build a pool")},
-    {"desc", N_("Build a given pool.")},
-    {NULL, NULL}
-};
-
-static const vshCmdOptDef opts_pool_build[] = {
-    {"pool", VSH_OT_DATA, VSH_OFLAG_REQ, N_("pool name or uuid")},
-    {"no-overwrite", VSH_OT_BOOL, 0, N_("do not overwrite an existing pool of this type")},
-    {"overwrite", VSH_OT_BOOL, 0, N_("overwrite any existing data")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdPoolBuild(vshControl *ctl, const vshCmd *cmd)
-{
-    virStoragePoolPtr pool;
-    bool ret = true;
-    const char *name;
-    unsigned int flags = 0;
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    if (!(pool = vshCommandOptPool(ctl, cmd, "pool", &name)))
-        return false;
-
-    if (vshCommandOptBool(cmd, "no-overwrite")) {
-        flags |= VIR_STORAGE_POOL_BUILD_NO_OVERWRITE;
-    }
-
-    if (vshCommandOptBool(cmd, "overwrite")) {
-        flags |= VIR_STORAGE_POOL_BUILD_OVERWRITE;
-    }
-
-    if (virStoragePoolBuild(pool, flags) == 0) {
-        vshPrint(ctl, _("Pool %s built\n"), name);
-    } else {
-        vshError(ctl, _("Failed to build pool %s"), name);
-        ret = false;
-    }
-
-    virStoragePoolFree(pool);
-
-    return ret;
-}
-
-/*
- * "pool-destroy" command
- */
-static const vshCmdInfo info_pool_destroy[] = {
-    {"help", N_("destroy (stop) a pool")},
-    {"desc",
-     N_("Forcefully stop a given pool. Raw data in the pool is untouched")},
-    {NULL, NULL}
-};
-
-static const vshCmdOptDef opts_pool_destroy[] = {
-    {"pool", VSH_OT_DATA, VSH_OFLAG_REQ, N_("pool name or uuid")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdPoolDestroy(vshControl *ctl, const vshCmd *cmd)
-{
-    virStoragePoolPtr pool;
-    bool ret = true;
-    const char *name;
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    if (!(pool = vshCommandOptPool(ctl, cmd, "pool", &name)))
-        return false;
-
-    if (virStoragePoolDestroy(pool) == 0) {
-        vshPrint(ctl, _("Pool %s destroyed\n"), name);
-    } else {
-        vshError(ctl, _("Failed to destroy pool %s"), name);
-        ret = false;
-    }
-
-    virStoragePoolFree(pool);
-    return ret;
-}
-
-
-/*
- * "pool-delete" command
- */
-static const vshCmdInfo info_pool_delete[] = {
-    {"help", N_("delete a pool")},
-    {"desc", N_("Delete a given pool.")},
-    {NULL, NULL}
-};
-
-static const vshCmdOptDef opts_pool_delete[] = {
-    {"pool", VSH_OT_DATA, VSH_OFLAG_REQ, N_("pool name or uuid")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdPoolDelete(vshControl *ctl, const vshCmd *cmd)
-{
-    virStoragePoolPtr pool;
-    bool ret = true;
-    const char *name;
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    if (!(pool = vshCommandOptPool(ctl, cmd, "pool", &name)))
-        return false;
-
-    if (virStoragePoolDelete(pool, 0) == 0) {
-        vshPrint(ctl, _("Pool %s deleted\n"), name);
-    } else {
-        vshError(ctl, _("Failed to delete pool %s"), name);
-        ret = false;
-    }
-
-    virStoragePoolFree(pool);
-    return ret;
-}
-
-
-/*
- * "pool-refresh" command
- */
-static const vshCmdInfo info_pool_refresh[] = {
-    {"help", N_("refresh a pool")},
-    {"desc", N_("Refresh a given pool.")},
-    {NULL, NULL}
-};
-
-static const vshCmdOptDef opts_pool_refresh[] = {
-    {"pool", VSH_OT_DATA, VSH_OFLAG_REQ, N_("pool name or uuid")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdPoolRefresh(vshControl *ctl, const vshCmd *cmd)
-{
-    virStoragePoolPtr pool;
-    bool ret = true;
-    const char *name;
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    if (!(pool = vshCommandOptPool(ctl, cmd, "pool", &name)))
-        return false;
-
-    if (virStoragePoolRefresh(pool, 0) == 0) {
-        vshPrint(ctl, _("Pool %s refreshed\n"), name);
-    } else {
-        vshError(ctl, _("Failed to refresh pool %s"), name);
-        ret = false;
-    }
-    virStoragePoolFree(pool);
-
-    return ret;
-}
-
-
-/*
- * "pool-dumpxml" command
- */
-static const vshCmdInfo info_pool_dumpxml[] = {
-    {"help", N_("pool information in XML")},
-    {"desc", N_("Output the pool information as an XML dump to stdout.")},
-    {NULL, NULL}
-};
-
-static const vshCmdOptDef opts_pool_dumpxml[] = {
-    {"pool", VSH_OT_DATA, VSH_OFLAG_REQ, N_("pool name or uuid")},
-    {"inactive", VSH_OT_BOOL, 0, N_("show inactive defined XML")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdPoolDumpXML(vshControl *ctl, const vshCmd *cmd)
-{
-    virStoragePoolPtr pool;
-    bool ret = true;
-    bool inactive = vshCommandOptBool(cmd, "inactive");
-    unsigned int flags = 0;
-    char *dump;
-
-    if (inactive)
-        flags |= VIR_STORAGE_XML_INACTIVE;
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    if (!(pool = vshCommandOptPool(ctl, cmd, "pool", NULL)))
-        return false;
-
-    dump = virStoragePoolGetXMLDesc(pool, flags);
-    if (dump != NULL) {
-        vshPrint(ctl, "%s", dump);
-        VIR_FREE(dump);
-    } else {
-        ret = false;
-    }
-
-    virStoragePoolFree(pool);
-    return ret;
-}
-
-
-/*
- * "pool-list" command
- */
-static const vshCmdInfo info_pool_list[] = {
-    {"help", N_("list pools")},
-    {"desc", N_("Returns list of pools.")},
-    {NULL, NULL}
-};
-
-static const vshCmdOptDef opts_pool_list[] = {
-    {"inactive", VSH_OT_BOOL, 0, N_("list inactive pools")},
-    {"all", VSH_OT_BOOL, 0, N_("list inactive & active pools")},
-    {"details", VSH_OT_BOOL, 0, N_("display extended details for pools")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdPoolList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
-{
-    virStoragePoolInfo info;
-    char **poolNames = NULL;
-    int i, ret;
-    bool functionReturn;
-    int numActivePools = 0, numInactivePools = 0, numAllPools = 0;
-    size_t stringLength = 0, nameStrLength = 0;
-    size_t autostartStrLength = 0, persistStrLength = 0;
-    size_t stateStrLength = 0, capStrLength = 0;
-    size_t allocStrLength = 0, availStrLength = 0;
-    struct poolInfoText {
-        char *state;
-        char *autostart;
-        char *persistent;
-        char *capacity;
-        char *allocation;
-        char *available;
-    };
-    struct poolInfoText *poolInfoTexts = NULL;
-
-    /* Determine the options passed by the user */
-    bool all = vshCommandOptBool(cmd, "all");
-    bool details = vshCommandOptBool(cmd, "details");
-    bool inactive = vshCommandOptBool(cmd, "inactive");
-    bool active = !inactive || all;
-    inactive |= all;
-
-    /* Check the connection to libvirtd daemon is still working */
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    /* Retrieve the number of active storage pools */
-    if (active) {
-        numActivePools = virConnectNumOfStoragePools(ctl->conn);
-        if (numActivePools < 0) {
-            vshError(ctl, "%s", _("Failed to list active pools"));
-            return false;
-        }
-    }
-
-    /* Retrieve the number of inactive storage pools */
-    if (inactive) {
-        numInactivePools = virConnectNumOfDefinedStoragePools(ctl->conn);
-        if (numInactivePools < 0) {
-            vshError(ctl, "%s", _("Failed to list inactive pools"));
-            return false;
-        }
-    }
-
-    /* Determine the total number of pools to list */
-    numAllPools = numActivePools + numInactivePools;
-
-    /* Allocate memory for arrays of storage pool names and info */
-    poolNames = vshCalloc(ctl, numAllPools, sizeof(*poolNames));
-    poolInfoTexts =
-        vshCalloc(ctl, numAllPools, sizeof(*poolInfoTexts));
-
-    /* Retrieve a list of active storage pool names */
-    if (active) {
-        if (virConnectListStoragePools(ctl->conn,
-                                       poolNames, numActivePools) < 0) {
-            vshError(ctl, "%s", _("Failed to list active pools"));
-            VIR_FREE(poolInfoTexts);
-            VIR_FREE(poolNames);
-            return false;
-        }
-    }
-
-    /* Add the inactive storage pools to the end of the name list */
-    if (inactive) {
-        if (virConnectListDefinedStoragePools(ctl->conn,
-                                              &poolNames[numActivePools],
-                                              numInactivePools) < 0) {
-            vshError(ctl, "%s", _("Failed to list inactive pools"));
-            VIR_FREE(poolInfoTexts);
-            VIR_FREE(poolNames);
-            return false;
-        }
-    }
-
-    /* Sort the storage pool names */
-    qsort(poolNames, numAllPools, sizeof(*poolNames), vshNameSorter);
-
-    /* Collect the storage pool information for display */
-    for (i = 0; i < numAllPools; i++) {
-        int autostart = 0, persistent = 0;
-
-        /* Retrieve a pool object, looking it up by name */
-        virStoragePoolPtr pool = virStoragePoolLookupByName(ctl->conn,
-                                                            poolNames[i]);
-        if (!pool) {
-            VIR_FREE(poolNames[i]);
-            continue;
-        }
-
-        /* Retrieve the autostart status of the pool */
-        if (virStoragePoolGetAutostart(pool, &autostart) < 0)
-            poolInfoTexts[i].autostart = vshStrdup(ctl, _("no autostart"));
-        else
-            poolInfoTexts[i].autostart = vshStrdup(ctl, autostart ?
-                                                    _("yes") : _("no"));
-
-        /* Retrieve the persistence status of the pool */
-        if (details) {
-            persistent = virStoragePoolIsPersistent(pool);
-            vshDebug(ctl, VSH_ERR_DEBUG, "Persistent flag value: %d\n",
-                     persistent);
-            if (persistent < 0)
-                poolInfoTexts[i].persistent = vshStrdup(ctl, _("unknown"));
-            else
-                poolInfoTexts[i].persistent = vshStrdup(ctl, persistent ?
-                                                         _("yes") : _("no"));
-
-            /* Keep the length of persistent string if longest so far */
-            stringLength = strlen(poolInfoTexts[i].persistent);
-            if (stringLength > persistStrLength)
-                persistStrLength = stringLength;
-        }
-
-        /* Collect further extended information about the pool */
-        if (virStoragePoolGetInfo(pool, &info) != 0) {
-            /* Something went wrong retrieving pool info, cope with it */
-            vshError(ctl, "%s", _("Could not retrieve pool information"));
-            poolInfoTexts[i].state = vshStrdup(ctl, _("unknown"));
-            if (details) {
-                poolInfoTexts[i].capacity = vshStrdup(ctl, _("unknown"));
-                poolInfoTexts[i].allocation = vshStrdup(ctl, _("unknown"));
-                poolInfoTexts[i].available = vshStrdup(ctl, _("unknown"));
-            }
-        } else {
-            /* Decide which state string to display */
-            if (details) {
-                /* --details option was specified, we're using detailed state
-                 * strings */
-                switch (info.state) {
-                case VIR_STORAGE_POOL_INACTIVE:
-                    poolInfoTexts[i].state = vshStrdup(ctl, _("inactive"));
-                    break;
-                case VIR_STORAGE_POOL_BUILDING:
-                    poolInfoTexts[i].state = vshStrdup(ctl, _("building"));
-                    break;
-                case VIR_STORAGE_POOL_RUNNING:
-                    poolInfoTexts[i].state = vshStrdup(ctl, _("running"));
-                    break;
-                case VIR_STORAGE_POOL_DEGRADED:
-                    poolInfoTexts[i].state = vshStrdup(ctl, _("degraded"));
-                    break;
-                case VIR_STORAGE_POOL_INACCESSIBLE:
-                    poolInfoTexts[i].state = vshStrdup(ctl, _("inaccessible"));
-                    break;
-                }
-
-                /* Create the pool size related strings */
-                if (info.state == VIR_STORAGE_POOL_RUNNING ||
-                    info.state == VIR_STORAGE_POOL_DEGRADED) {
-                    double val;
-                    const char *unit;
-
-                    /* Create the capacity output string */
-                    val = prettyCapacity(info.capacity, &unit);
-                    ret = virAsprintf(&poolInfoTexts[i].capacity,
-                                      "%.2lf %s", val, unit);
-                    if (ret < 0) {
-                        /* An error occurred creating the string, return */
-                        goto asprintf_failure;
-                    }
-
-                    /* Create the allocation output string */
-                    val = prettyCapacity(info.allocation, &unit);
-                    ret = virAsprintf(&poolInfoTexts[i].allocation,
-                                      "%.2lf %s", val, unit);
-                    if (ret < 0) {
-                        /* An error occurred creating the string, return */
-                        goto asprintf_failure;
-                    }
-
-                    /* Create the available space output string */
-                    val = prettyCapacity(info.available, &unit);
-                    ret = virAsprintf(&poolInfoTexts[i].available,
-                                      "%.2lf %s", val, unit);
-                    if (ret < 0) {
-                        /* An error occurred creating the string, return */
-                        goto asprintf_failure;
-                    }
-                } else {
-                    /* Capacity related information isn't available */
-                    poolInfoTexts[i].capacity = vshStrdup(ctl, _("-"));
-                    poolInfoTexts[i].allocation = vshStrdup(ctl, _("-"));
-                    poolInfoTexts[i].available = vshStrdup(ctl, _("-"));
-                }
-
-                /* Keep the length of capacity string if longest so far */
-                stringLength = strlen(poolInfoTexts[i].capacity);
-                if (stringLength > capStrLength)
-                    capStrLength = stringLength;
-
-                /* Keep the length of allocation string if longest so far */
-                stringLength = strlen(poolInfoTexts[i].allocation);
-                if (stringLength > allocStrLength)
-                    allocStrLength = stringLength;
-
-                /* Keep the length of available string if longest so far */
-                stringLength = strlen(poolInfoTexts[i].available);
-                if (stringLength > availStrLength)
-                    availStrLength = stringLength;
-            } else {
-                /* --details option was not specified, only active/inactive
-                * state strings are used */
-                if (info.state == VIR_STORAGE_POOL_INACTIVE)
-                    poolInfoTexts[i].state = vshStrdup(ctl, _("inactive"));
-                else
-                    poolInfoTexts[i].state = vshStrdup(ctl, _("active"));
-            }
-        }
-
-        /* Keep the length of name string if longest so far */
-        stringLength = strlen(poolNames[i]);
-        if (stringLength > nameStrLength)
-            nameStrLength = stringLength;
-
-        /* Keep the length of state string if longest so far */
-        stringLength = strlen(poolInfoTexts[i].state);
-        if (stringLength > stateStrLength)
-            stateStrLength = stringLength;
-
-        /* Keep the length of autostart string if longest so far */
-        stringLength = strlen(poolInfoTexts[i].autostart);
-        if (stringLength > autostartStrLength)
-            autostartStrLength = stringLength;
-
-        /* Free the pool object */
-        virStoragePoolFree(pool);
-    }
-
-    /* If the --details option wasn't selected, we output the pool
-     * info using the fixed string format from previous versions to
-     * maintain backward compatibility.
-     */
-
-    /* Output basic info then return if --details option not selected */
-    if (!details) {
-        /* Output old style header */
-        vshPrintExtra(ctl, "%-20s %-10s %-10s\n", _("Name"), _("State"),
-                      _("Autostart"));
-        vshPrintExtra(ctl, "-----------------------------------------\n");
-
-        /* Output old style pool info */
-        for (i = 0; i < numAllPools; i++) {
-            vshPrint(ctl, "%-20s %-10s %-10s\n",
-                 poolNames[i],
-                 poolInfoTexts[i].state,
-                 poolInfoTexts[i].autostart);
-        }
-
-        /* Cleanup and return */
-        functionReturn = true;
-        goto cleanup;
-    }
-
-    /* We only get here if the --details option was selected. */
-
-    /* Use the length of name header string if it's longest */
-    stringLength = strlen(_("Name"));
-    if (stringLength > nameStrLength)
-        nameStrLength = stringLength;
-
-    /* Use the length of state header string if it's longest */
-    stringLength = strlen(_("State"));
-    if (stringLength > stateStrLength)
-        stateStrLength = stringLength;
-
-    /* Use the length of autostart header string if it's longest */
-    stringLength = strlen(_("Autostart"));
-    if (stringLength > autostartStrLength)
-        autostartStrLength = stringLength;
-
-    /* Use the length of persistent header string if it's longest */
-    stringLength = strlen(_("Persistent"));
-    if (stringLength > persistStrLength)
-        persistStrLength = stringLength;
-
-    /* Use the length of capacity header string if it's longest */
-    stringLength = strlen(_("Capacity"));
-    if (stringLength > capStrLength)
-        capStrLength = stringLength;
-
-    /* Use the length of allocation header string if it's longest */
-    stringLength = strlen(_("Allocation"));
-    if (stringLength > allocStrLength)
-        allocStrLength = stringLength;
-
-    /* Use the length of available header string if it's longest */
-    stringLength = strlen(_("Available"));
-    if (stringLength > availStrLength)
-        availStrLength = stringLength;
-
-    /* Display the string lengths for debugging. */
-    vshDebug(ctl, VSH_ERR_DEBUG, "Longest name string = %lu chars\n",
-             (unsigned long) nameStrLength);
-    vshDebug(ctl, VSH_ERR_DEBUG, "Longest state string = %lu chars\n",
-             (unsigned long) stateStrLength);
-    vshDebug(ctl, VSH_ERR_DEBUG, "Longest autostart string = %lu chars\n",
-             (unsigned long) autostartStrLength);
-    vshDebug(ctl, VSH_ERR_DEBUG, "Longest persistent string = %lu chars\n",
-             (unsigned long) persistStrLength);
-    vshDebug(ctl, VSH_ERR_DEBUG, "Longest capacity string = %lu chars\n",
-             (unsigned long) capStrLength);
-    vshDebug(ctl, VSH_ERR_DEBUG, "Longest allocation string = %lu chars\n",
-             (unsigned long) allocStrLength);
-    vshDebug(ctl, VSH_ERR_DEBUG, "Longest available string = %lu chars\n",
-             (unsigned long) availStrLength);
-
-    /* Create the output template.  Each column is sized according to
-     * the longest string.
-     */
-    char *outputStr;
-    ret = virAsprintf(&outputStr,
-              "%%-%lus  %%-%lus  %%-%lus  %%-%lus  %%%lus  %%%lus  %%%lus\n",
-              (unsigned long) nameStrLength,
-              (unsigned long) stateStrLength,
-              (unsigned long) autostartStrLength,
-              (unsigned long) persistStrLength,
-              (unsigned long) capStrLength,
-              (unsigned long) allocStrLength,
-              (unsigned long) availStrLength);
-    if (ret < 0) {
-        /* An error occurred creating the string, return */
-        goto asprintf_failure;
-    }
-
-    /* Display the header */
-    vshPrint(ctl, outputStr, _("Name"), _("State"), _("Autostart"),
-             _("Persistent"), _("Capacity"), _("Allocation"), _("Available"));
-    for (i = nameStrLength + stateStrLength + autostartStrLength
-                           + persistStrLength + capStrLength
-                           + allocStrLength + availStrLength
-                           + 12; i > 0; i--)
-        vshPrintExtra(ctl, "-");
-    vshPrintExtra(ctl, "\n");
-
-    /* Display the pool info rows */
-    for (i = 0; i < numAllPools; i++) {
-        vshPrint(ctl, outputStr,
-                 poolNames[i],
-                 poolInfoTexts[i].state,
-                 poolInfoTexts[i].autostart,
-                 poolInfoTexts[i].persistent,
-                 poolInfoTexts[i].capacity,
-                 poolInfoTexts[i].allocation,
-                 poolInfoTexts[i].available);
-    }
-
-    /* Cleanup and return */
-    functionReturn = true;
-    goto cleanup;
-
-asprintf_failure:
-
-    /* Display an appropriate error message then cleanup and return */
-    switch (errno) {
-    case ENOMEM:
-        /* Couldn't allocate memory */
-        vshError(ctl, "%s", _("Out of memory"));
-        break;
-    default:
-        /* Some other error */
-        vshError(ctl, _("virAsprintf failed (errno %d)"), errno);
-    }
-    functionReturn = false;
-
-cleanup:
-
-    /* Safely free the memory allocated in this function */
-    for (i = 0; i < numAllPools; i++) {
-        /* Cleanup the memory for one pool info structure */
-        VIR_FREE(poolInfoTexts[i].state);
-        VIR_FREE(poolInfoTexts[i].autostart);
-        VIR_FREE(poolInfoTexts[i].persistent);
-        VIR_FREE(poolInfoTexts[i].capacity);
-        VIR_FREE(poolInfoTexts[i].allocation);
-        VIR_FREE(poolInfoTexts[i].available);
-        VIR_FREE(poolNames[i]);
-    }
-
-    /* Cleanup the memory for the initial arrays*/
-    VIR_FREE(poolInfoTexts);
-    VIR_FREE(poolNames);
-
-    /* Return the desired value */
-    return functionReturn;
-}
-
-/*
- * "find-storage-pool-sources-as" command
- */
-static const vshCmdInfo info_find_storage_pool_sources_as[] = {
-    {"help", N_("find potential storage pool sources")},
-    {"desc", N_("Returns XML <sources> document.")},
-    {NULL, NULL}
-};
-
-static const vshCmdOptDef opts_find_storage_pool_sources_as[] = {
-    {"type", VSH_OT_DATA, VSH_OFLAG_REQ,
-     N_("type of storage pool sources to find")},
-    {"host", VSH_OT_DATA, VSH_OFLAG_NONE, N_("optional host to query")},
-    {"port", VSH_OT_DATA, VSH_OFLAG_NONE, N_("optional port to query")},
-    {"initiator", VSH_OT_DATA, VSH_OFLAG_NONE, N_("optional initiator IQN to use for query")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdPoolDiscoverSourcesAs(vshControl * ctl, const vshCmd * cmd ATTRIBUTE_UNUSED)
-{
-    const char *type = NULL, *host = NULL;
-    char *srcSpec = NULL;
-    char *srcList;
-    const char *initiator = NULL;
-
-    if (vshCommandOptString(cmd, "type", &type) <= 0 ||
-        vshCommandOptString(cmd, "host", &host) < 0 ||
-        vshCommandOptString(cmd, "initiator", &initiator) < 0) {
-        vshError(ctl,"%s", _("missing argument"));
-        return false;
-    }
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-
-    if (host) {
-        const char *port = NULL;
-        virBuffer buf = VIR_BUFFER_INITIALIZER;
-
-        if (vshCommandOptString(cmd, "port", &port) < 0) {
-            vshError(ctl, "%s", _("missing argument"));
-            virBufferFreeAndReset(&buf);
-            return false;
-        }
-        virBufferAddLit(&buf, "<source>\n");
-        virBufferAsprintf(&buf, "  <host name='%s'", host);
-        if (port)
-            virBufferAsprintf(&buf, " port='%s'", port);
-        virBufferAddLit(&buf, "/>\n");
-        if (initiator) {
-            virBufferAddLit(&buf, "  <initiator>\n");
-            virBufferAsprintf(&buf, "    <iqn name='%s'/>\n", initiator);
-            virBufferAddLit(&buf, "  </initiator>\n");
-        }
-        virBufferAddLit(&buf, "</source>\n");
-        if (virBufferError(&buf)) {
-            vshError(ctl, "%s", _("Out of memory"));
-            return false;
-        }
-        srcSpec = virBufferContentAndReset(&buf);
-    }
-
-    srcList = virConnectFindStoragePoolSources(ctl->conn, type, srcSpec, 0);
-    VIR_FREE(srcSpec);
-    if (srcList == NULL) {
-        vshError(ctl, _("Failed to find any %s pool sources"), type);
-        return false;
-    }
-    vshPrint(ctl, "%s", srcList);
-    VIR_FREE(srcList);
-
-    return true;
-}
-
-
-/*
- * "find-storage-pool-sources" command
- */
-static const vshCmdInfo info_find_storage_pool_sources[] = {
-    {"help", N_("discover potential storage pool sources")},
-    {"desc", N_("Returns XML <sources> document.")},
-    {NULL, NULL}
-};
-
-static const vshCmdOptDef opts_find_storage_pool_sources[] = {
-    {"type", VSH_OT_DATA, VSH_OFLAG_REQ,
-     N_("type of storage pool sources to discover")},
-    {"srcSpec", VSH_OT_DATA, VSH_OFLAG_NONE,
-     N_("optional file of source xml to query for pools")},
+static const vshCmdOptDef opts_nwfilter_dumpxml[] = {
+    {"nwfilter", VSH_OT_DATA, VSH_OFLAG_REQ, N_("network filter name or uuid")},
     {NULL, 0, 0, NULL}
 };
 
 static bool
-cmdPoolDiscoverSources(vshControl * ctl, const vshCmd * cmd ATTRIBUTE_UNUSED)
+cmdNWFilterDumpXML(vshControl *ctl, const vshCmd *cmd)
 {
-    const char *type = NULL, *srcSpecFile = NULL;
-    char *srcSpec = NULL, *srcList;
-
-    if (vshCommandOptString(cmd, "type", &type) <= 0)
-        return false;
-
-    if (vshCommandOptString(cmd, "srcSpec", &srcSpecFile) < 0) {
-        vshError(ctl, "%s", _("missing option"));
-        return false;
-    }
+    virNWFilterPtr nwfilter;
+    bool ret = true;
+    char *dump;
 
     if (!vshConnectionUsability(ctl, ctl->conn))
         return false;
 
-    if (srcSpecFile && virFileReadAll(srcSpecFile, VIRSH_MAX_XML_FILE, &srcSpec) < 0)
+    if (!(nwfilter = vshCommandOptNWFilter(ctl, cmd, NULL)))
         return false;
 
-    srcList = virConnectFindStoragePoolSources(ctl->conn, type, srcSpec, 0);
-    VIR_FREE(srcSpec);
-    if (srcList == NULL) {
-        vshError(ctl, _("Failed to find any %s pool sources"), type);
-        return false;
+    dump = virNWFilterGetXMLDesc(nwfilter, 0);
+    if (dump != NULL) {
+        vshPrint(ctl, "%s", dump);
+        VIR_FREE(dump);
+    } else {
+        ret = false;
     }
-    vshPrint(ctl, "%s", srcList);
-    VIR_FREE(srcList);
 
-    return true;
+    virNWFilterFree(nwfilter);
+    return ret;
 }
 
-
 /*
- * "pool-info" command
+ * "nwfilter-list" command
  */
-static const vshCmdInfo info_pool_info[] = {
-    {"help", N_("storage pool information")},
-    {"desc", N_("Returns basic information about the storage pool.")},
+static const vshCmdInfo info_nwfilter_list[] = {
+    {"help", N_("list network filters")},
+    {"desc", N_("Returns list of network filters.")},
     {NULL, NULL}
 };
 
-static const vshCmdOptDef opts_pool_info[] = {
-    {"pool", VSH_OT_DATA, VSH_OFLAG_REQ, N_("pool name or uuid")},
+static const vshCmdOptDef opts_nwfilter_list[] = {
     {NULL, 0, 0, NULL}
 };
 
 static bool
-cmdPoolInfo(vshControl *ctl, const vshCmd *cmd)
+cmdNWFilterList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
 {
-    virStoragePoolInfo info;
-    virStoragePoolPtr pool;
-    int autostart = 0;
-    int persistent = 0;
-    bool ret = true;
+    int numfilters, i;
+    char **names;
     char uuid[VIR_UUID_STRING_BUFLEN];
 
     if (!vshConnectionUsability(ctl, ctl->conn))
         return false;
 
-    if (!(pool = vshCommandOptPool(ctl, cmd, "pool", NULL)))
+    numfilters = virConnectNumOfNWFilters(ctl->conn);
+    if (numfilters < 0) {
+        vshError(ctl, "%s", _("Failed to list network filters"));
         return false;
+    }
 
-    vshPrint(ctl, "%-15s %s\n", _("Name:"), virStoragePoolGetName(pool));
-
-    if (virStoragePoolGetUUIDString(pool, &uuid[0])==0)
-        vshPrint(ctl, "%-15s %s\n", _("UUID:"), uuid);
+    names = vshMalloc(ctl, sizeof(char *) * numfilters);
 
-    if (virStoragePoolGetInfo(pool, &info) == 0) {
-        double val;
-        const char *unit;
-        switch (info.state) {
-        case VIR_STORAGE_POOL_INACTIVE:
-            vshPrint(ctl, "%-15s %s\n", _("State:"),
-                     _("inactive"));
-            break;
-        case VIR_STORAGE_POOL_BUILDING:
-            vshPrint(ctl, "%-15s %s\n", _("State:"),
-                     _("building"));
-            break;
-        case VIR_STORAGE_POOL_RUNNING:
-            vshPrint(ctl, "%-15s %s\n", _("State:"),
-                     _("running"));
-            break;
-        case VIR_STORAGE_POOL_DEGRADED:
-            vshPrint(ctl, "%-15s %s\n", _("State:"),
-                     _("degraded"));
-            break;
-        case VIR_STORAGE_POOL_INACCESSIBLE:
-            vshPrint(ctl, "%-15s %s\n", _("State:"),
-                     _("inaccessible"));
-            break;
-        }
+    if ((numfilters = virConnectListNWFilters(ctl->conn, names,
+                                              numfilters)) < 0) {
+        vshError(ctl, "%s", _("Failed to list network filters"));
+        VIR_FREE(names);
+        return false;
+    }
 
-        /* Check and display whether the pool is persistent or not */
-        persistent = virStoragePoolIsPersistent(pool);
-        vshDebug(ctl, VSH_ERR_DEBUG, "Pool persistent flag value: %d\n",
-                 persistent);
-        if (persistent < 0)
-            vshPrint(ctl, "%-15s %s\n", _("Persistent:"),  _("unknown"));
-        else
-            vshPrint(ctl, "%-15s %s\n", _("Persistent:"), persistent ? _("yes") : _("no"));
-
-        /* Check and display whether the pool is autostarted or not */
-        virStoragePoolGetAutostart(pool, &autostart);
-        vshDebug(ctl, VSH_ERR_DEBUG, "Pool autostart flag value: %d\n",
-                 autostart);
-        if (autostart < 0)
-            vshPrint(ctl, "%-15s %s\n", _("Autostart:"), _("no autostart"));
-        else
-            vshPrint(ctl, "%-15s %s\n", _("Autostart:"), autostart ? _("yes") : _("no"));
+    qsort(&names[0], numfilters, sizeof(char *), vshNameSorter);
 
-        if (info.state == VIR_STORAGE_POOL_RUNNING ||
-            info.state == VIR_STORAGE_POOL_DEGRADED) {
-            val = prettyCapacity(info.capacity, &unit);
-            vshPrint(ctl, "%-15s %2.2lf %s\n", _("Capacity:"), val, unit);
+    vshPrintExtra(ctl, "%-36s  %-20s \n", _("UUID"), _("Name"));
+    vshPrintExtra(ctl,
+       "----------------------------------------------------------------\n");
 
-            val = prettyCapacity(info.allocation, &unit);
-            vshPrint(ctl, "%-15s %2.2lf %s\n", _("Allocation:"), val, unit);
+    for (i = 0; i < numfilters; i++) {
+        virNWFilterPtr nwfilter =
+            virNWFilterLookupByName(ctl->conn, names[i]);
 
-            val = prettyCapacity(info.available, &unit);
-            vshPrint(ctl, "%-15s %2.2lf %s\n", _("Available:"), val, unit);
+        /* this kind of work with networks is not atomic operation */
+        if (!nwfilter) {
+            VIR_FREE(names[i]);
+            continue;
         }
-    } else {
-        ret = false;
+
+        virNWFilterGetUUIDString(nwfilter, uuid);
+        vshPrint(ctl, "%-36s  %-20s\n",
+                 uuid,
+                 virNWFilterGetName(nwfilter));
+        virNWFilterFree(nwfilter);
+        VIR_FREE(names[i]);
     }
 
-    virStoragePoolFree(pool);
-    return ret;
+    VIR_FREE(names);
+    return true;
 }
 
 
 /*
- * "pool-name" command
+ * "nwfilter-edit" command
  */
-static const vshCmdInfo info_pool_name[] = {
-    {"help", N_("convert a pool UUID to pool name")},
-    {"desc", ""},
+static const vshCmdInfo info_nwfilter_edit[] = {
+    {"help", N_("edit XML configuration for a network filter")},
+    {"desc", N_("Edit the XML configuration for a network filter.")},
     {NULL, NULL}
 };
 
-static const vshCmdOptDef opts_pool_name[] = {
-    {"pool", VSH_OT_DATA, VSH_OFLAG_REQ, N_("pool uuid")},
+static const vshCmdOptDef opts_nwfilter_edit[] = {
+    {"nwfilter", VSH_OT_DATA, VSH_OFLAG_REQ, N_("network filter name or uuid")},
     {NULL, 0, 0, NULL}
 };
 
 static bool
-cmdPoolName(vshControl *ctl, const vshCmd *cmd)
+cmdNWFilterEdit(vshControl *ctl, const vshCmd *cmd)
 {
-    virStoragePoolPtr pool;
+    bool ret = false;
+    virNWFilterPtr nwfilter = NULL;
+    virNWFilterPtr nwfilter_edited = NULL;
 
     if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
-    if (!(pool = vshCommandOptPoolBy(ctl, cmd, "pool", NULL,
-                                           VSH_BYUUID)))
-        return false;
-
-    vshPrint(ctl, "%s\n", virStoragePoolGetName(pool));
-    virStoragePoolFree(pool);
-    return true;
-}
-
-
-/*
- * "pool-start" command
- */
-static const vshCmdInfo info_pool_start[] = {
-    {"help", N_("start a (previously defined) inactive pool")},
-    {"desc", N_("Start a pool.")},
-    {NULL, NULL}
-};
+        goto cleanup;
 
-static const vshCmdOptDef opts_pool_start[] = {
-    {"pool", VSH_OT_DATA, VSH_OFLAG_REQ, N_("name or uuid of the inactive pool")},
-    {NULL, 0, 0, NULL}
-};
+    nwfilter = vshCommandOptNWFilter(ctl, cmd, NULL);
+    if (nwfilter == NULL)
+        goto cleanup;
 
-static bool
-cmdPoolStart(vshControl *ctl, const vshCmd *cmd)
-{
-    virStoragePoolPtr pool;
-    bool ret = true;
-    const char *name = NULL;
+#define EDIT_GET_XML virNWFilterGetXMLDesc(nwfilter, 0)
+#define EDIT_NOT_CHANGED \
+    vshPrint(ctl, _("Network filter %s XML "            \
+                    "configuration not changed.\n"),    \
+             virNWFilterGetName(nwfilter));             \
+    ret = true; goto edit_cleanup;
+#define EDIT_DEFINE \
+    (nwfilter_edited = virNWFilterDefineXML(ctl->conn, doc_edited))
+#define EDIT_FREE \
+    if (nwfilter_edited)    \
+        virNWFilterFree(nwfilter);
+#include "virsh-edit.c"
 
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        return false;
+    vshPrint(ctl, _("Network filter %s XML configuration edited.\n"),
+             virNWFilterGetName(nwfilter_edited));
 
-    if (!(pool = vshCommandOptPool(ctl, cmd, "pool", &name)))
-         return false;
+    ret = true;
 
-    if (virStoragePoolCreate(pool, 0) == 0) {
-        vshPrint(ctl, _("Pool %s started\n"), name);
-    } else {
-        vshError(ctl, _("Failed to start pool %s"), name);
-        ret = false;
-    }
+cleanup:
+    if (nwfilter)
+        virNWFilterFree(nwfilter);
+    if (nwfilter_edited)
+        virNWFilterFree(nwfilter_edited);
 
-    virStoragePoolFree(pool);
     return ret;
 }
 
 /*
- * "pool-undefine" command
+ * "nodedev-create" command
  */
-static const vshCmdInfo info_pool_undefine[] = {
-    {"help", N_("undefine an inactive pool")},
-    {"desc", N_("Undefine the configuration for an inactive pool.")},
+static const vshCmdInfo info_node_device_create[] = {
+    {"help", N_("create a device defined "
+                          "by an XML file on the node")},
+    {"desc", N_("Create a device on the node.  Note that this "
+                          "command creates devices on the physical host "
+                          "that can then be assigned to a virtual machine.")},
     {NULL, NULL}
 };
 
-static const vshCmdOptDef opts_pool_undefine[] = {
-    {"pool", VSH_OT_DATA, VSH_OFLAG_REQ, N_("pool name or uuid")},
+static const vshCmdOptDef opts_node_device_create[] = {
+    {"file", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("file containing an XML description of the device")},
     {NULL, 0, 0, NULL}
 };
 
 static bool
-cmdPoolUndefine(vshControl *ctl, const vshCmd *cmd)
+cmdNodeDeviceCreate(vshControl *ctl, const vshCmd *cmd)
 {
-    virStoragePoolPtr pool;
+    virNodeDevicePtr dev = NULL;
+    const char *from = NULL;
     bool ret = true;
-    const char *name;
+    char *buffer;
 
     if (!vshConnectionUsability(ctl, ctl->conn))
         return false;
 
-    if (!(pool = vshCommandOptPool(ctl, cmd, "pool", &name)))
+    if (vshCommandOptString(cmd, "file", &from) <= 0)
+        return false;
+
+    if (virFileReadAll(from, VIRSH_MAX_XML_FILE, &buffer) < 0)
         return false;
 
-    if (virStoragePoolUndefine(pool) == 0) {
-        vshPrint(ctl, _("Pool %s has been undefined\n"), name);
+    dev = virNodeDeviceCreateXML(ctl->conn, buffer, 0);
+    VIR_FREE(buffer);
+
+    if (dev != NULL) {
+        vshPrint(ctl, _("Node device %s created from %s\n"),
+                 virNodeDeviceGetName(dev), from);
+        virNodeDeviceFree(dev);
     } else {
-        vshError(ctl, _("Failed to undefine pool %s"), name);
+        vshError(ctl, _("Failed to create node device from %s"), from);
         ret = false;
     }
 
-    virStoragePoolFree(pool);
     return ret;
 }
 
 
 /*
- * "pool-uuid" command
+ * "nodedev-destroy" command
  */
-static const vshCmdInfo info_pool_uuid[] = {
-    {"help", N_("convert a pool name to pool UUID")},
-    {"desc", ""},
+static const vshCmdInfo info_node_device_destroy[] = {
+    {"help", N_("destroy (stop) a device on the node")},
+    {"desc", N_("Destroy a device on the node.  Note that this "
+                "command destroys devices on the physical host")},
     {NULL, NULL}
 };
 
-static const vshCmdOptDef opts_pool_uuid[] = {
-    {"pool", VSH_OT_DATA, VSH_OFLAG_REQ, N_("pool name")},
+static const vshCmdOptDef opts_node_device_destroy[] = {
+    {"name", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("name of the device to be destroyed")},
     {NULL, 0, 0, NULL}
 };
 
 static bool
-cmdPoolUuid(vshControl *ctl, const vshCmd *cmd)
+cmdNodeDeviceDestroy(vshControl *ctl, const vshCmd *cmd)
 {
-    virStoragePoolPtr pool;
-    char uuid[VIR_UUID_STRING_BUFLEN];
+    virNodeDevicePtr dev = NULL;
+    bool ret = true;
+    const char *name = NULL;
 
-    if (!vshConnectionUsability(ctl, ctl->conn))
+    if (!vshConnectionUsability(ctl, ctl->conn)) {
         return false;
+    }
 
-    if (!(pool = vshCommandOptPoolBy(ctl, cmd, "pool", NULL,
-                                           VSH_BYNAME)))
+    if (vshCommandOptString(cmd, "name", &name) <= 0)
         return false;
 
-    if (virStoragePoolGetUUIDString(pool, uuid) != -1)
-        vshPrint(ctl, "%s\n", uuid);
-    else
-        vshError(ctl, "%s", _("failed to get pool UUID"));
+    dev = virNodeDeviceLookupByName(ctl->conn, name);
 
-    virStoragePoolFree(pool);
-    return true;
+    if (virNodeDeviceDestroy(dev) == 0) {
+        vshPrint(ctl, _("Destroyed node device '%s'\n"), name);
+    } else {
+        vshError(ctl, _("Failed to destroy node device '%s'"), name);
+        ret = false;
+    }
+
+    virNodeDeviceFree(dev);
+    return ret;
 }
 
 /*
@@ -5582,75 +4276,6 @@ cmdNetworkEdit(vshControl *ctl, const vshCmd *cmd)
 }
 
 /*
- * "pool-edit" command
- */
-static const vshCmdInfo info_pool_edit[] = {
-    {"help", N_("edit XML configuration for a storage pool")},
-    {"desc", N_("Edit the XML configuration for a storage pool.")},
-    {NULL, NULL}
-};
-
-static const vshCmdOptDef opts_pool_edit[] = {
-    {"pool", VSH_OT_DATA, VSH_OFLAG_REQ, N_("pool name or uuid")},
-    {NULL, 0, 0, NULL}
-};
-
-static bool
-cmdPoolEdit(vshControl *ctl, const vshCmd *cmd)
-{
-    bool ret = false;
-    virStoragePoolPtr pool = NULL;
-    virStoragePoolPtr pool_edited = NULL;
-    unsigned int flags = VIR_STORAGE_XML_INACTIVE;
-    char *tmp_desc = NULL;
-
-    if (!vshConnectionUsability(ctl, ctl->conn))
-        goto cleanup;
-
-    pool = vshCommandOptPool(ctl, cmd, "pool", NULL);
-    if (pool == NULL)
-        goto cleanup;
-
-    /* Some old daemons don't support _INACTIVE flag */
-    if (!(tmp_desc = virStoragePoolGetXMLDesc(pool, flags))) {
-        if (last_error->code == VIR_ERR_INVALID_ARG) {
-            flags &= ~VIR_STORAGE_XML_INACTIVE;
-            virFreeError(last_error);
-            last_error = NULL;
-        } else {
-            goto cleanup;
-        }
-    } else {
-        VIR_FREE(tmp_desc);
-    }
-
-#define EDIT_GET_XML virStoragePoolGetXMLDesc(pool, flags)
-#define EDIT_NOT_CHANGED \
-    vshPrint(ctl, _("Pool %s XML configuration not changed.\n"),    \
-             virStoragePoolGetName(pool));                          \
-    ret = true; goto edit_cleanup;
-#define EDIT_DEFINE \
-    (pool_edited = virStoragePoolDefineXML(ctl->conn, doc_edited, 0))
-#define EDIT_FREE \
-    if (pool_edited)    \
-        virStoragePoolFree(pool_edited);
-#include "virsh-edit.c"
-
-    vshPrint(ctl, _("Pool %s XML configuration edited.\n"),
-             virStoragePoolGetName(pool_edited));
-
-    ret = true;
-
- cleanup:
-    if (pool)
-        virStoragePoolFree(pool);
-    if (pool_edited)
-        virStoragePoolFree(pool_edited);
-
-    return ret;
-}
-
-/*
  * "quit" command
  */
 static const vshCmdInfo info_quit[] = {
@@ -8205,41 +6830,6 @@ vshCommandOptInterfaceBy(vshControl *ctl, const vshCmd *cmd,
     return iface;
 }
 
-static virStoragePoolPtr
-vshCommandOptPoolBy(vshControl *ctl, const vshCmd *cmd, const char *optname,
-                    const char **name, int flag)
-{
-    virStoragePoolPtr pool = NULL;
-    const char *n = NULL;
-
-    if (vshCommandOptString(cmd, optname, &n) <= 0)
-        return NULL;
-
-    vshDebug(ctl, VSH_ERR_INFO, "%s: found option <%s>: %s\n",
-             cmd->def->name, optname, n);
-
-    if (name)
-        *name = n;
-
-    /* try it by UUID */
-    if ((flag & VSH_BYUUID) && strlen(n) == VIR_UUID_STRING_BUFLEN-1) {
-        vshDebug(ctl, VSH_ERR_DEBUG, "%s: <%s> trying as pool UUID\n",
-                 cmd->def->name, optname);
-        pool = virStoragePoolLookupByUUIDString(ctl->conn, n);
-    }
-    /* try it by NAME */
-    if (pool == NULL && (flag & VSH_BYNAME)) {
-        vshDebug(ctl, VSH_ERR_DEBUG, "%s: <%s> trying as pool NAME\n",
-                 cmd->def->name, optname);
-        pool = virStoragePoolLookupByName(ctl->conn, n);
-    }
-
-    if (!pool)
-        vshError(ctl, _("failed to get pool '%s'"), n);
-
-    return pool;
-}
-
 static virSecretPtr
 vshCommandOptSecret(vshControl *ctl, const vshCmd *cmd, const char **name)
 {
@@ -9706,6 +8296,8 @@ static const vshCmdDef domMonitoringCmds[] = {
     {NULL, NULL, NULL, NULL, 0}
 };
 
+#include "virsh-pool.c"
+
 static const vshCmdDef storagePoolCmds[] = {
     {"find-storage-pool-sources-as", cmdPoolDiscoverSourcesAs,
      opts_find_storage_pool_sources_as, info_find_storage_pool_sources_as, 0},
-- 
1.7.7.3


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]