[libvirt] [PATCH 3/8] parallels: implement functions for domain life cycle management

[Dmitry Guryanov]

Add functions for create/shutdown/destroy and suspend/resume domain.

Signed-off-by: Dmitry Guryanov <dguryanov at parallels.com>
---
 src/parallels/parallels_driver.c |  143 ++++++++++++++++++++++++++++++++++++++
 src/parallels/parallels_utils.c  |   18 +++++
 src/parallels/parallels_utils.h  |    2 +
 3 files changed, 163 insertions(+), 0 deletions(-)

diff --git a/src/parallels/parallels_driver.c b/src/parallels/parallels_driver.c
index c716b25..8c20d27 100644
--- a/src/parallels/parallels_driver.c
+++ b/src/parallels/parallels_driver.c
@@ -128,6 +128,12 @@ parallelsDomObjFreePrivate(void *p)
     VIR_FREE(p);
 };
 
+static void
+parallelsDomainEventQueue(parallelsConnPtr driver, virDomainEventPtr event)
+{
+    virDomainEventStateQueue(driver->domainEventState, event);
+}
+
 static virCapsPtr
 parallelsBuildCapabilities(void)
 {
@@ -805,6 +811,138 @@ parallelsDomainGetAutostart(virDomainPtr domain, int *autostart)
     return ret;
 }
 
+typedef int (*parallelsChangeStateFunc)    (virDomainObjPtr privdom);
+#define PARALLELS_UUID(x)     (((parallelsDomObjPtr)(x->privateData))->uuid)
+
+static int
+parallelsDomainChangeState(virDomainPtr domain,
+                           virDomainState req_state, const char *req_state_name,
+                           parallelsChangeStateFunc chstate,
+                           virDomainState new_state, int reason,
+                           int event_type, int event_detail)
+{
+    parallelsConnPtr privconn = domain->conn->privateData;
+    virDomainObjPtr privdom;
+    virDomainEventPtr event = NULL;
+    int state;
+    int ret = -1;
+
+    parallelsDriverLock(privconn);
+    privdom = virDomainFindByUUID(&privconn->domains, domain->uuid);
+    parallelsDriverUnlock(privconn);
+
+    if (privdom == NULL) {
+        parallelsDomNotFoundError(domain);
+        goto cleanup;
+    }
+
+    state = virDomainObjGetState(privdom, NULL);
+    if (state != req_state) {
+        virReportError(VIR_ERR_INTERNAL_ERROR, _("domain '%s' not %s"),
+                       privdom->def->name, req_state_name);
+        goto cleanup;
+    }
+
+    if (chstate(privdom))
+        goto cleanup;
+
+    virDomainObjSetState(privdom, new_state, reason);
+
+    event = virDomainEventNewFromObj(privdom, event_type, event_detail);
+    ret = 0;
+
+  cleanup:
+    if (privdom)
+        virDomainObjUnlock(privdom);
+
+    if (event) {
+        parallelsDriverLock(privconn);
+        parallelsDomainEventQueue(privconn, event);
+        parallelsDriverUnlock(privconn);
+    }
+    return ret;
+}
+
+static int parallelsPause(virDomainObjPtr privdom)
+{
+    return parallelsCmdRun(PRLCTL, "pause", PARALLELS_UUID(privdom), NULL);
+}
+
+static int
+parallelsPauseDomain(virDomainPtr domain)
+{
+    return parallelsDomainChangeState(domain,
+                                      VIR_DOMAIN_RUNNING, "running",
+                                      parallelsPause,
+                                      VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_USER,
+                                      VIR_DOMAIN_EVENT_SUSPENDED,
+                                      VIR_DOMAIN_EVENT_SUSPENDED_PAUSED);
+}
+
+static int parallelsResume(virDomainObjPtr privdom)
+{
+    return parallelsCmdRun(PRLCTL, "resume", PARALLELS_UUID(privdom), NULL);
+}
+
+static int
+parallelsResumeDomain(virDomainPtr domain)
+{
+    return parallelsDomainChangeState(domain,
+                                      VIR_DOMAIN_PAUSED, "paused",
+                                      parallelsResume,
+                                      VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_UNPAUSED,
+                                      VIR_DOMAIN_EVENT_RESUMED,
+                                      VIR_DOMAIN_EVENT_RESUMED_UNPAUSED);
+}
+
+static int parallelsStart(virDomainObjPtr privdom)
+{
+    return parallelsCmdRun(PRLCTL, "start", PARALLELS_UUID(privdom), NULL);
+}
+
+static int
+parallelsDomainCreate(virDomainPtr domain)
+{
+    return parallelsDomainChangeState(domain,
+                                      VIR_DOMAIN_SHUTOFF, "stopped",
+                                      parallelsStart,
+                                      VIR_DOMAIN_RUNNING, VIR_DOMAIN_EVENT_STARTED_BOOTED,
+                                      VIR_DOMAIN_EVENT_STARTED,
+                                      VIR_DOMAIN_EVENT_STARTED_BOOTED);
+}
+
+static int parallelsKill(virDomainObjPtr privdom)
+{
+    return parallelsCmdRun(PRLCTL, "stop", PARALLELS_UUID(privdom), "--kill", NULL);
+}
+
+static int
+parallelsDestroyDomain(virDomainPtr domain)
+{
+    return parallelsDomainChangeState(domain,
+                                      VIR_DOMAIN_RUNNING, "running",
+                                      parallelsKill,
+                                      VIR_DOMAIN_SHUTOFF, VIR_DOMAIN_SHUTOFF_DESTROYED,
+                                      VIR_DOMAIN_EVENT_STOPPED,
+                                      VIR_DOMAIN_EVENT_STOPPED_DESTROYED);
+}
+
+static int parallelsStop(virDomainObjPtr privdom)
+{
+    return parallelsCmdRun(PRLCTL, "stop", PARALLELS_UUID(privdom), NULL);
+}
+
+static int
+parallelsShutdownDomain(virDomainPtr domain)
+{
+    return parallelsDomainChangeState(domain,
+                                      VIR_DOMAIN_RUNNING, "running",
+                                      parallelsStop,
+                                      VIR_DOMAIN_SHUTOFF, VIR_DOMAIN_SHUTOFF_SHUTDOWN,
+                                      VIR_DOMAIN_EVENT_STOPPED,
+                                      VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN);
+}
+
 static virDriver parallelsDriver = {
     .no = VIR_DRV_PARALLELS,
     .name = "Parallels",
@@ -828,6 +966,11 @@ static virDriver parallelsDriver = {
     .domainGetXMLDesc = parallelsDomainGetXMLDesc,    /* 0.10.0 */
     .domainIsPersistent = parallelsDomainIsPersistent,        /* 0.10.0 */
     .domainGetAutostart = parallelsDomainGetAutostart,        /* 0.10.0 */
+    .domainSuspend = parallelsPauseDomain,    /* 0.10.0 */
+    .domainResume = parallelsResumeDomain,    /* 0.10.0 */
+    .domainDestroy = parallelsDestroyDomain,  /* 0.10.0 */
+    .domainShutdown = parallelsShutdownDomain, /* 0.10.0 */
+    .domainCreate = parallelsDomainCreate,    /* 0.10.0 */
 };
 
 /**
diff --git a/src/parallels/parallels_utils.c b/src/parallels/parallels_utils.c
index 102ccfc..78d45e0 100644
--- a/src/parallels/parallels_utils.c
+++ b/src/parallels/parallels_utils.c
@@ -90,3 +90,21 @@ parallelsParseOutput(const char *binary, ...)
     VIR_FREE(outbuf);
     return jobj;
 }
+
+/*
+ * Run prlctl command and check for errors
+ *
+ * Return value is 0 in case of success, else - -1
+ */
+int
+parallelsCmdRun(const char *binary, ...)
+{
+    int ret;
+    va_list list;
+
+    va_start(list, binary);
+    ret = parallelsDoCmdRun(NULL, binary, list);
+    va_end(list);
+
+    return ret;
+}
diff --git a/src/parallels/parallels_utils.h b/src/parallels/parallels_utils.h
index a17cbab..d997ad3 100644
--- a/src/parallels/parallels_utils.h
+++ b/src/parallels/parallels_utils.h
@@ -25,5 +25,7 @@
 
 virJSONValuePtr parallelsParseOutput(const char *binary, ...)
     ATTRIBUTE_NONNULL(1) ATTRIBUTE_SENTINEL;
+int parallelsCmdRun(const char *binary, ...)
+    ATTRIBUTE_NONNULL(1) ATTRIBUTE_SENTINEL;
 
 #endif
-- 
1.7.1