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

[libvirt] [PATCH v7 2/8] parallels: add functions to list domains and get info



Parallels driver is 'stateless', like vmware or openvz drivers.
It collects information about domains during startup using
command-line utility prlctl. VMs in Parallels Cloud Server are
identified by UUIDs or unique names, which can be used as
respective fields in virDomainDef structure. Currently only basic
info, like description, virtual cpus number and memory amount, is
implemented. Querying devices information will be added in the
next patches.

Parallels Cloud Server doesn't support non-persistent domains -
you can't run a domain having only disk image, it must always be
registered in system.

Functions for querying domain info have been just copied from
test driver with some changes - they extract needed data from
previously created list of virDomainObj objects.

Signed-off-by: Dmitry Guryanov <dguryanov parallels com>
---
 po/POTFILES.in                   |    2 +
 src/Makefile.am                  |    3 +-
 src/parallels/parallels_driver.c |  540 +++++++++++++++++++++++++++++++++++++-
 src/parallels/parallels_driver.h |   14 +
 src/parallels/parallels_utils.c  |   89 +++++++
 5 files changed, 646 insertions(+), 2 deletions(-)
 create mode 100644 src/parallels/parallels_utils.c

diff --git a/po/POTFILES.in b/po/POTFILES.in
index 1917899..dcb0813 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -64,6 +64,8 @@ src/openvz/openvz_driver.c
 src/openvz/openvz_util.c
 src/phyp/phyp_driver.c
 src/parallels/parallels_driver.c
+src/parallels/parallels_driver.h
+src/parallels/parallels_utils.c
 src/qemu/qemu_agent.c
 src/qemu/qemu_bridge_filter.c
 src/qemu/qemu_capabilities.c
diff --git a/src/Makefile.am b/src/Makefile.am
index 128a1a4..a89585d 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -481,7 +481,8 @@ HYPERV_DRIVER_EXTRA_DIST =							\
 
 PARALLELS_DRIVER_SOURCES =					\
 		parallels/parallels_driver.h			\
-		parallels/parallels_driver.c
+		parallels/parallels_driver.c			\
+		parallels/parallels_utils.c
 
 NETWORK_DRIVER_SOURCES =					\
 		network/bridge_driver.h network/bridge_driver.c
diff --git a/src/parallels/parallels_driver.c b/src/parallels/parallels_driver.c
index 4d83f9f..69bc966 100644
--- a/src/parallels/parallels_driver.c
+++ b/src/parallels/parallels_driver.c
@@ -50,12 +50,13 @@
 #include "configmake.h"
 #include "storage_file.h"
 #include "nodeinfo.h"
-#include "json.h"
+#include "domain_conf.h"
 
 #include "parallels_driver.h"
 
 #define VIR_FROM_THIS VIR_FROM_PARALLELS
 
+static void parallelsFreeDomObj(void *p);
 static virCapsPtr parallelsBuildCapabilities(void);
 static int parallelsClose(virConnectPtr conn);
 
@@ -77,6 +78,12 @@ parallelsDefaultConsoleType(const char *ostype ATTRIBUTE_UNUSED)
     return VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SERIAL;
 }
 
+static void
+parallelsFreeDomObj(void *p)
+{
+    VIR_FREE(p);
+};
+
 static virCapsPtr
 parallelsBuildCapabilities(void)
 {
@@ -125,6 +132,221 @@ parallelsGetCapabilities(virConnectPtr conn)
     return xml;
 }
 
+/*
+ * Must be called with privconn->lock held
+ */
+static virDomainObjPtr
+parallelsLoadDomain(parallelsConnPtr privconn, virJSONValuePtr jobj)
+{
+    virDomainObjPtr dom = NULL;
+    virDomainDefPtr def = NULL;
+    parallelsDomObjPtr pdom = NULL;
+    virJSONValuePtr jobj2, jobj3;
+    const char *tmp;
+    char *endptr;
+    unsigned long mem;
+    unsigned int x;
+
+    if (VIR_ALLOC(def) < 0)
+        goto no_memory;
+
+    def->virtType = VIR_DOMAIN_VIRT_PARALLELS;
+    def->id = -1;
+
+    tmp = virJSONValueObjectGetString(jobj, "Name");
+    if (!tmp) {
+        parallelsParseError();
+        goto cleanup;
+    }
+    if (!(def->name = strdup(tmp)))
+        goto no_memory;
+
+    tmp = virJSONValueObjectGetString(jobj, "ID");
+    if (!tmp) {
+        parallelsParseError();
+        goto cleanup;
+    }
+
+    if (virUUIDParse(tmp, def->uuid) < 0) {
+        parallelsError(VIR_ERR_INTERNAL_ERROR, "%s",
+                 _("UUID in config file malformed"));
+        goto cleanup;
+    }
+
+    tmp = virJSONValueObjectGetString(jobj, "Description");
+    if (!tmp) {
+        parallelsParseError();
+        goto cleanup;
+    }
+    if (!(def->description = strdup(tmp)))
+        goto no_memory;
+
+    jobj2 = virJSONValueObjectGet(jobj, "Hardware");
+    if (!jobj2) {
+        parallelsParseError();
+        goto cleanup;
+    }
+
+    jobj3 = virJSONValueObjectGet(jobj2, "cpu");
+    if (!jobj3) {
+        parallelsParseError();
+        goto cleanup;
+    }
+
+    if (virJSONValueObjectGetNumberUint(jobj3, "cpus", &x) < 0) {
+        parallelsParseError();
+        goto cleanup;
+    }
+    def->vcpus = x;
+    def->maxvcpus = x;
+
+    jobj3 = virJSONValueObjectGet(jobj2, "memory");
+    if (!jobj3) {
+        parallelsParseError();
+        goto cleanup;
+    }
+
+    tmp = virJSONValueObjectGetString(jobj3, "size");
+
+    if (virStrToLong_ul(tmp, &endptr, 10, &mem) < 0) {
+        parallelsParseError();
+        goto cleanup;
+    }
+
+    if (!STREQ(endptr, "Mb")) {
+        parallelsParseError();
+        goto cleanup;
+    }
+
+    def->mem.max_balloon = mem;
+    def->mem.max_balloon <<= 10;
+    def->mem.cur_balloon = def->mem.max_balloon;
+
+    if (!(def->os.type = strdup("hvm")))
+        goto no_memory;
+
+    if (!(def->os.init = strdup("/sbin/init")))
+        goto no_memory;
+
+    if (!(dom = virDomainAssignDef(privconn->caps,
+                                   &privconn->domains, def, false)))
+        goto cleanup;
+    /* dom is locked here */
+
+    if (VIR_ALLOC(pdom) < 0)
+        goto no_memory_unlock;
+    dom->privateDataFreeFunc = parallelsFreeDomObj;
+    dom->privateData = pdom;
+
+    if (virJSONValueObjectGetNumberUint(jobj, "EnvID", &x) < 0)
+        goto cleanup_unlock;
+    pdom->id = x;
+    tmp = virJSONValueObjectGetString(jobj, "ID");
+    if (!tmp) {
+        parallelsParseError();
+        goto cleanup_unlock;
+    }
+    if (!(pdom->uuid = strdup(tmp)))
+        goto no_memory_unlock;
+
+    tmp = virJSONValueObjectGetString(jobj, "OS");
+    if (!tmp)
+        goto cleanup_unlock;
+    if (!(pdom->os = strdup(tmp)))
+        goto no_memory_unlock;
+
+    dom->persistent = 1;
+
+    tmp = virJSONValueObjectGetString(jobj, "State");
+    if (!tmp) {
+        parallelsParseError();
+        goto cleanup_unlock;
+    }
+
+    /* TODO: handle all possible states */
+    if (STREQ(tmp, "running")) {
+        virDomainObjSetState(dom, VIR_DOMAIN_RUNNING,
+                             VIR_DOMAIN_RUNNING_BOOTED);
+        def->id = pdom->id;
+    }
+
+    tmp = virJSONValueObjectGetString(jobj, "Autostart");
+    if (!tmp) {
+        parallelsParseError();
+        goto cleanup_unlock;
+    }
+    if (STREQ(tmp, "on"))
+        dom->autostart = 1;
+    else
+        dom->autostart = 0;
+
+    virDomainObjUnlock(dom);
+
+    return dom;
+
+  no_memory_unlock:
+    virReportOOMError();
+  cleanup_unlock:
+    virDomainObjUnlock(dom);
+    /* domain list was locked, so nobody could get 'dom'. It has only
+     * one reference and virDomainObjUnref return 0 here */
+    if (virDomainObjUnref(dom))
+        parallelsError(VIR_ERR_INTERNAL_ERROR, _("Can't free virDomainObj"));
+    return NULL;
+  no_memory:
+    virReportOOMError();
+  cleanup:
+    virDomainDefFree(def);
+    return NULL;
+}
+
+/*
+ * Must be called with privconn->lock held
+ *
+ * if domain_name is NULL - load information about all
+ * registered domains.
+ */
+static int
+parallelsLoadDomains(parallelsConnPtr privconn, const char *domain_name)
+{
+    int count, i;
+    virJSONValuePtr jobj;
+    virJSONValuePtr jobj2;
+    virDomainObjPtr dom = NULL;
+    int ret = -1;
+
+    jobj = parallelsParseOutput(PRLCTL, "list", "-j", "-a",
+                          "-i", "-H", "--vmtype", "vm", domain_name, NULL);
+    if (!jobj) {
+        parallelsParseError();
+        goto cleanup;
+    }
+
+    count = virJSONValueArraySize(jobj);
+    if (count < 1) {
+        parallelsParseError();
+        goto cleanup;
+    }
+
+    for (i = 0; i < count; i++) {
+        jobj2 = virJSONValueArrayGet(jobj, i);
+        if (!jobj2) {
+            parallelsParseError();
+            goto cleanup;
+        }
+
+        dom = parallelsLoadDomain(privconn, jobj2);
+        if (!dom)
+            goto cleanup;
+    }
+
+    ret = 0;
+
+  cleanup:
+    virJSONValueFree(jobj);
+    return ret;
+}
+
 static int
 parallelsOpenDefault(virConnectPtr conn)
 {
@@ -150,6 +372,9 @@ parallelsOpenDefault(virConnectPtr conn)
     if (virDomainObjListInit(&privconn->domains) < 0)
         goto error;
 
+    if (parallelsLoadDomains(privconn, NULL))
+        goto error;
+
     return VIR_DRV_OPEN_SUCCESS;
 
   error:
@@ -236,6 +461,306 @@ parallelsGetVersion(virConnectPtr conn ATTRIBUTE_UNUSED, unsigned long *hvVer)
     return 0;
 }
 
+static int
+parallelsListDomains(virConnectPtr conn, int *ids, int maxids)
+{
+    parallelsConnPtr privconn = conn->privateData;
+    int n;
+
+    parallelsDriverLock(privconn);
+    n = virDomainObjListGetActiveIDs(&privconn->domains, ids, maxids);
+    parallelsDriverUnlock(privconn);
+
+    return n;
+}
+
+static int
+parallelsNumOfDomains(virConnectPtr conn)
+{
+    parallelsConnPtr privconn = conn->privateData;
+    int count;
+
+    parallelsDriverLock(privconn);
+    count = virDomainObjListNumOfDomains(&privconn->domains, 1);
+    parallelsDriverUnlock(privconn);
+
+    return count;
+}
+
+static int
+parallelsListDefinedDomains(virConnectPtr conn, char **const names, int maxnames)
+{
+    parallelsConnPtr privconn = conn->privateData;
+    int n;
+
+    parallelsDriverLock(privconn);
+    memset(names, 0, sizeof(*names) * maxnames);
+    n = virDomainObjListGetInactiveNames(&privconn->domains, names,
+                                         maxnames);
+    parallelsDriverUnlock(privconn);
+
+    return n;
+}
+
+static int
+parallelsNumOfDefinedDomains(virConnectPtr conn)
+{
+    parallelsConnPtr privconn = conn->privateData;
+    int count;
+
+    parallelsDriverLock(privconn);
+    count = virDomainObjListNumOfDomains(&privconn->domains, 0);
+    parallelsDriverUnlock(privconn);
+
+    return count;
+}
+
+static virDomainPtr
+parallelsLookupDomainByID(virConnectPtr conn, int id)
+{
+    parallelsConnPtr privconn = conn->privateData;
+    virDomainPtr ret = NULL;
+    virDomainObjPtr dom;
+
+    parallelsDriverLock(privconn);
+    dom = virDomainFindByID(&privconn->domains, id);
+    parallelsDriverUnlock(privconn);
+
+    if (dom == NULL) {
+        parallelsError(VIR_ERR_NO_DOMAIN, NULL);
+        goto cleanup;
+    }
+
+    ret = virGetDomain(conn, dom->def->name, dom->def->uuid);
+    if (ret)
+        ret->id = dom->def->id;
+
+  cleanup:
+    if (dom)
+        virDomainObjUnlock(dom);
+    return ret;
+}
+
+static virDomainPtr
+parallelsLookupDomainByUUID(virConnectPtr conn, const unsigned char *uuid)
+{
+    parallelsConnPtr privconn = conn->privateData;
+    virDomainPtr ret = NULL;
+    virDomainObjPtr dom;
+
+    parallelsDriverLock(privconn);
+    dom = virDomainFindByUUID(&privconn->domains, uuid);
+    parallelsDriverUnlock(privconn);
+
+    if (dom == NULL) {
+        parallelsError(VIR_ERR_NO_DOMAIN, NULL);
+        goto cleanup;
+    }
+
+    ret = virGetDomain(conn, dom->def->name, dom->def->uuid);
+    if (ret)
+        ret->id = dom->def->id;
+
+  cleanup:
+    if (dom)
+        virDomainObjUnlock(dom);
+    return ret;
+}
+
+static virDomainPtr
+parallelsLookupDomainByName(virConnectPtr conn, const char *name)
+{
+    parallelsConnPtr privconn = conn->privateData;
+    virDomainPtr ret = NULL;
+    virDomainObjPtr dom;
+
+    parallelsDriverLock(privconn);
+    dom = virDomainFindByName(&privconn->domains, name);
+    parallelsDriverUnlock(privconn);
+
+    if (dom == NULL) {
+        parallelsError(VIR_ERR_NO_DOMAIN, NULL);
+        goto cleanup;
+    }
+
+    ret = virGetDomain(conn, dom->def->name, dom->def->uuid);
+    if (ret)
+        ret->id = dom->def->id;
+
+  cleanup:
+    if (dom)
+        virDomainObjUnlock(dom);
+    return ret;
+}
+
+static int
+parallelsGetDomainInfo(virDomainPtr domain, virDomainInfoPtr info)
+{
+    parallelsConnPtr privconn = domain->conn->privateData;
+    virDomainObjPtr privdom;
+    int ret = -1;
+
+    parallelsDriverLock(privconn);
+    privdom = virDomainFindByName(&privconn->domains, domain->name);
+    parallelsDriverUnlock(privconn);
+
+    if (privdom == NULL) {
+        parallelsError(VIR_ERR_NO_DOMAIN,
+                 _("no domain with matching name '%s'"), domain->name);
+        goto cleanup;
+    }
+
+    info->state = virDomainObjGetState(privdom, NULL);
+    info->memory = privdom->def->mem.cur_balloon;
+    info->maxMem = privdom->def->mem.max_balloon;
+    info->nrVirtCpu = privdom->def->vcpus;
+    info->cpuTime = 0;
+    ret = 0;
+
+  cleanup:
+    if (privdom)
+        virDomainObjUnlock(privdom);
+    return ret;
+}
+
+static char *
+parallelsGetOSType(virDomainPtr dom)
+{
+    parallelsConnPtr privconn = dom->conn->privateData;
+    virDomainObjPtr privdom;
+    parallelsDomObjPtr pdom;
+
+    char *ret = NULL;
+
+    parallelsDriverLock(privconn);
+    privdom = virDomainFindByName(&privconn->domains, dom->name);
+    if (privdom == NULL) {
+        parallelsError(VIR_ERR_NO_DOMAIN,
+                 _("no domain with matching name '%s'"), dom->name);
+        goto cleanup;
+    }
+
+    pdom = privdom->privateData;
+
+    if (!(ret = strdup(pdom->os)))
+        virReportOOMError();
+
+  cleanup:
+    if (privdom)
+        virDomainObjUnlock(privdom);
+    parallelsDriverUnlock(privconn);
+    return ret;
+}
+
+static int
+parallelsDomainIsPersistent(virDomainPtr dom)
+{
+    parallelsConnPtr privconn = dom->conn->privateData;
+    virDomainObjPtr privdom;
+    int ret = -1;
+
+    parallelsDriverLock(privconn);
+    privdom = virDomainFindByName(&privconn->domains, dom->name);
+    if (privdom == NULL) {
+        parallelsError(VIR_ERR_NO_DOMAIN,
+                 _("no domain with matching name '%s'"), dom->name);
+        goto cleanup;
+    }
+
+    ret = 1;
+
+  cleanup:
+    if (privdom)
+        virDomainObjUnlock(privdom);
+    parallelsDriverUnlock(privconn);
+    return ret;
+}
+
+static int
+parallelsDomainGetState(virDomainPtr domain,
+                  int *state, int *reason, unsigned int flags)
+{
+    parallelsConnPtr privconn = domain->conn->privateData;
+    virDomainObjPtr privdom;
+    int ret = -1;
+    virCheckFlags(0, -1);
+
+    parallelsDriverLock(privconn);
+    privdom = virDomainFindByName(&privconn->domains, domain->name);
+    parallelsDriverUnlock(privconn);
+
+    if (privdom == NULL) {
+        parallelsError(VIR_ERR_NO_DOMAIN,
+                 _("no domain with matching name '%s'"), domain->name);
+        goto cleanup;
+    }
+
+    *state = virDomainObjGetState(privdom, reason);
+    ret = 0;
+
+  cleanup:
+    if (privdom)
+        virDomainObjUnlock(privdom);
+    return ret;
+}
+
+static char *
+parallelsDomainGetXMLDesc(virDomainPtr domain, unsigned int flags)
+{
+    parallelsConnPtr privconn = domain->conn->privateData;
+    virDomainDefPtr def;
+    virDomainObjPtr privdom;
+    char *ret = NULL;
+
+    /* Flags checked by virDomainDefFormat */
+
+    parallelsDriverLock(privconn);
+    privdom = virDomainFindByName(&privconn->domains, domain->name);
+    parallelsDriverUnlock(privconn);
+
+    if (privdom == NULL) {
+        parallelsError(VIR_ERR_NO_DOMAIN,
+                 _("no domain with matching name '%s'"), domain->name);
+        goto cleanup;
+    }
+
+    def = (flags & VIR_DOMAIN_XML_INACTIVE) &&
+        privdom->newDef ? privdom->newDef : privdom->def;
+
+    ret = virDomainDefFormat(def, flags);
+
+  cleanup:
+    if (privdom)
+        virDomainObjUnlock(privdom);
+    return ret;
+}
+
+static int
+parallelsDomainGetAutostart(virDomainPtr domain, int *autostart)
+{
+    parallelsConnPtr privconn = domain->conn->privateData;
+    virDomainObjPtr privdom;
+    int ret = -1;
+
+    parallelsDriverLock(privconn);
+    privdom = virDomainFindByName(&privconn->domains, domain->name);
+    parallelsDriverUnlock(privconn);
+
+    if (privdom == NULL) {
+        parallelsError(VIR_ERR_NO_DOMAIN,
+                 _("no domain with matching name '%s'"), domain->name);
+        goto cleanup;
+    }
+
+    *autostart = privdom->autostart;
+    ret = 0;
+
+  cleanup:
+    if (privdom)
+        virDomainObjUnlock(privdom);
+    return ret;
+}
+
 static virDriver parallelsDriver = {
     .no = VIR_DRV_PARALLELS,
     .name = "PARALLELS",
@@ -245,6 +770,19 @@ static virDriver parallelsDriver = {
     .getHostname = virGetHostname,      /* 0.9.12 */
     .nodeGetInfo = nodeGetInfo,      /* 0.9.12 */
     .getCapabilities = parallelsGetCapabilities,      /* 0.9.12 */
+    .listDomains = parallelsListDomains,      /* 0.9.12 */
+    .numOfDomains = parallelsNumOfDomains,    /* 0.9.12 */
+    .listDefinedDomains = parallelsListDefinedDomains,        /* 0.9.12 */
+    .numOfDefinedDomains = parallelsNumOfDefinedDomains,      /* 0.9.12 */
+    .domainLookupByID = parallelsLookupDomainByID,    /* 0.9.12 */
+    .domainLookupByUUID = parallelsLookupDomainByUUID,        /* 0.9.12 */
+    .domainLookupByName = parallelsLookupDomainByName,        /* 0.9.12 */
+    .domainGetOSType = parallelsGetOSType,    /* 0.9.12 */
+    .domainGetInfo = parallelsGetDomainInfo,  /* 0.9.12 */
+    .domainGetState = parallelsDomainGetState,        /* 0.9.12 */
+    .domainGetXMLDesc = parallelsDomainGetXMLDesc,    /* 0.9.12 */
+    .domainIsPersistent = parallelsDomainIsPersistent,        /* 0.9.12 */
+    .domainGetAutostart = parallelsDomainGetAutostart,        /* 0.9.12 */
 };
 
 /**
diff --git a/src/parallels/parallels_driver.h b/src/parallels/parallels_driver.h
index c04db35..8398c02 100644
--- a/src/parallels/parallels_driver.h
+++ b/src/parallels/parallels_driver.h
@@ -28,11 +28,23 @@
 # include "storage_conf.h"
 # include "domain_event.h"
 
+# include "json.h"
+
 # define parallelsError(code, ...)                                         \
         virReportErrorHelper(VIR_FROM_TEST, code, __FILE__,         \
                              __FUNCTION__, __LINE__, __VA_ARGS__)
 # define PRLCTL      "prlctl"
+# define parallelsParseError()                                                          \
+        virReportErrorHelper(VIR_FROM_TEST, VIR_ERR_OPERATION_FAILED, __FILE__,  \
+                             __FUNCTION__, __LINE__, _("Can't parse prlctl output"))
+
+struct parallelsDomObj {
+    int id;
+    char *uuid;
+    char *os;
+};
 
+typedef struct parallelsDomObj *parallelsDomObjPtr;
 
 struct _parallelsConn {
     virMutex lock;
@@ -48,4 +60,6 @@ typedef struct _parallelsConn *parallelsConnPtr;
 
 int parallelsRegister(void);
 
+virJSONValuePtr parallelsParseOutput(const char *binary, ...) ATTRIBUTE_NONNULL(1) ATTRIBUTE_SENTINEL;
+
 #endif
diff --git a/src/parallels/parallels_utils.c b/src/parallels/parallels_utils.c
new file mode 100644
index 0000000..845adf4
--- /dev/null
+++ b/src/parallels/parallels_utils.c
@@ -0,0 +1,89 @@
+/*
+ * parallels_utils.c: core driver functions for managing
+ * Parallels Virtuozzo Server hosts
+ *
+ * Copyright (C) 2012 Parallels, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ *
+ */
+
+#include <config.h>
+
+#include <stdarg.h>
+
+#include "command.h"
+#include "virterror_internal.h"
+#include "memory.h"
+
+#include "parallels_driver.h"
+
+static int
+parallelsDoCmdRun(char **outbuf, const char *binary, va_list list)
+{
+    virCommandPtr cmd = virCommandNew(binary);
+    const char *arg;
+    char *scmd = NULL;
+    int ret = -1;
+
+    while ((arg = va_arg(list, const char *)) != NULL)
+        virCommandAddArg(cmd, arg);
+
+    if (outbuf)
+        virCommandSetOutputBuffer(cmd, outbuf);
+
+    scmd = virCommandToString(cmd);
+    if (!scmd)
+        goto cleanup;
+
+    if (virCommandRun(cmd, NULL))
+        goto cleanup;
+
+    ret = 0;
+
+  cleanup:
+    VIR_FREE(scmd);
+    virCommandFree(cmd);
+    if (ret)
+        VIR_FREE(*outbuf);
+    return ret;
+}
+
+/*
+ * Run command and parse its JSON output, return
+ * pointer to virJSONValue or NULL in case of error.
+ */
+virJSONValuePtr
+parallelsParseOutput(const char *binary, ...)
+{
+    char *outbuf;
+    virJSONValuePtr jobj = NULL;
+    va_list list;
+    int ret;
+
+    va_start(list, binary);
+    ret = parallelsDoCmdRun(&outbuf, binary, list);
+    va_end(list);
+    if (ret)
+        return NULL;
+
+    jobj = virJSONValueFromString(outbuf);
+    if (!jobj)
+        parallelsError(VIR_ERR_INTERNAL_ERROR, "%s: %s",
+                 _("invalid output from prlctl"), outbuf);
+
+    VIR_FREE(outbuf);
+    return jobj;
+}
-- 
1.7.1


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