parallels: login to parallels SDK

Add files parallels_sdk.c and parallels_sdk.h for code
which works with SDK, so libvirt's code will not mix with
dealing with parallels SDK.

To use Parallels SDK you must first call PrlApi_InitEx function,
and then you will be able to connect to a server with
PrlSrv_LoginLocalEx function. When you've done you must call
PrlApi_Deinit. So let's call PrlApi_InitEx on first .connectOpen,
count number of connections and deinitialize, when this counter
becomes zero.

Signed-off-by: Dmitry Guryanov <dguryanov@parallels.com>

diff --git a/po/POTFILES.in b/po/POTFILES.in
index b769dfe504a7e26d227ad488c572923a3920c098..020a9ac8850f78f2fe74a23f7e158e0d237d0fdd 100644 (file)
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -96,6 +96,7 @@ src/openvz/openvz_driver.c
 src/openvz/openvz_util.c
 src/parallels/parallels_driver.c
 src/parallels/parallels_network.c
+src/parallels/parallels_sdk.c
 src/parallels/parallels_utils.c
 src/parallels/parallels_utils.h
 src/parallels/parallels_storage.c

diff --git a/src/Makefile.am b/src/Makefile.am
index 8f18ec48a5a2bf94289dd35bd2ed67dab771edc8..e65177f1bde5b01a304b157cc17e8882a34cdc48 100644 (file)
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -788,7 +788,9 @@ PARALLELS_DRIVER_SOURCES =                                  \
                parallels/parallels_utils.c                     \
                parallels/parallels_utils.h                     \
                parallels/parallels_storage.c           \
-               parallels/parallels_network.c
+               parallels/parallels_network.c           \
+               parallels/parallels_sdk.h                       \
+               parallels/parallels_sdk.c
 
 BHYVE_DRIVER_SOURCES =                                         \
                bhyve/bhyve_capabilities.c                      \

diff --git a/src/parallels/parallels_driver.c b/src/parallels/parallels_driver.c
index 13a7d95d7e972c500218c581bc0e151b60a49b86..516a296eb62265dd4903a1dc6c521ef8ae6f0b27 100644 (file)
--- a/src/parallels/parallels_driver.c
+++ b/src/parallels/parallels_driver.c
@@ -55,6 +55,7 @@
 
 #include "parallels_driver.h"
 #include "parallels_utils.h"
+#include "parallels_sdk.h"
 
 #define VIR_FROM_THIS VIR_FROM_PARALLELS
 
@@ -929,9 +930,17 @@ parallelsOpenDefault(virConnectPtr conn)
     if (virMutexInit(&privconn->lock) < 0) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                        _("cannot initialize mutex"));
-        goto error;
+        goto err_free;
+    }
+
+    if (prlsdkInit(privconn)) {
+        VIR_DEBUG("%s", _("Can't initialize Parallels SDK"));
+        goto err_free;
     }
 
+    if (prlsdkConnect(privconn) < 0)
+        goto err_free;
+
     if (!(privconn->caps = parallelsBuildCapabilities()))
         goto error;
 
@@ -953,6 +962,9 @@ parallelsOpenDefault(virConnectPtr conn)
     virObjectUnref(privconn->domains);
     virObjectUnref(privconn->caps);
     virStoragePoolObjListFree(&privconn->pools);
+    prlsdkDisconnect(privconn);
+    prlsdkDeinit();
+ err_free:
     VIR_FREE(privconn);
     return VIR_DRV_OPEN_ERROR;
 }
@@ -999,7 +1011,9 @@ parallelsConnectClose(virConnectPtr conn)
     virObjectUnref(privconn->caps);
     virObjectUnref(privconn->xmlopt);
     virObjectUnref(privconn->domains);
+    prlsdkDisconnect(privconn);
     conn->privateData = NULL;
+    prlsdkDeinit();
 
     parallelsDriverUnlock(privconn);
     virMutexDestroy(&privconn->lock);

diff --git a/src/parallels/parallels_sdk.c b/src/parallels/parallels_sdk.c
new file mode 100644 (file)
index 0000000..1c77d27
--- /dev/null
+++ b/src/parallels/parallels_sdk.c
@@ -0,0 +1,241 @@
+/*
+ * parallels_sdk.c: core driver functions for managing
+ * Parallels Cloud Server hosts
+ *
+ * Copyright (C) 2014 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, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <config.h>
+
+#include "virerror.h"
+#include "viralloc.h"
+
+#include "parallels_sdk.h"
+
+#define VIR_FROM_THIS VIR_FROM_PARALLELS
+#define JOB_INFINIT_WAIT_TIMEOUT UINT_MAX
+
+PRL_UINT32 defaultJobTimeout = JOB_INFINIT_WAIT_TIMEOUT;
+
+/*
+ * Log error description
+ */
+static void
+logPrlErrorHelper(PRL_RESULT err, const char *filename,
+                  const char *funcname, size_t linenr)
+{
+    char *msg1 = NULL, *msg2 = NULL;
+    PRL_UINT32 len = 0;
+
+    /* Get required buffer length */
+    PrlApi_GetResultDescription(err, PRL_TRUE, PRL_FALSE, NULL, &len);
+
+    if (VIR_ALLOC_N(msg1, len) < 0)
+        goto cleanup;
+
+    /* get short error description */
+    PrlApi_GetResultDescription(err, PRL_TRUE, PRL_FALSE, msg1, &len);
+
+    PrlApi_GetResultDescription(err, PRL_FALSE, PRL_FALSE, NULL, &len);
+
+    if (VIR_ALLOC_N(msg2, len) < 0)
+        goto cleanup;
+
+    /* get long error description */
+    PrlApi_GetResultDescription(err, PRL_FALSE, PRL_FALSE, msg2, &len);
+
+    virReportErrorHelper(VIR_FROM_THIS, VIR_ERR_INTERNAL_ERROR,
+                         filename, funcname, linenr,
+                         _("%s %s"), msg1, msg2);
+
+ cleanup:
+    VIR_FREE(msg1);
+    VIR_FREE(msg2);
+}
+
+#define logPrlError(code)                          \
+    logPrlErrorHelper(code, __FILE__,              \
+                         __FUNCTION__, __LINE__)
+
+static PRL_RESULT
+logPrlEventErrorHelper(PRL_HANDLE event, const char *filename,
+                       const char *funcname, size_t linenr)
+{
+    PRL_RESULT ret, retCode;
+    char *msg1 = NULL, *msg2 = NULL;
+    PRL_UINT32 len = 0;
+    int err = -1;
+
+    if ((ret = PrlEvent_GetErrCode(event, &retCode))) {
+        logPrlError(ret);
+        return ret;
+    }
+
+    PrlEvent_GetErrString(event, PRL_TRUE, PRL_FALSE, NULL, &len);
+
+    if (VIR_ALLOC_N(msg1, len) < 0)
+        goto cleanup;
+
+    PrlEvent_GetErrString(event, PRL_TRUE, PRL_FALSE, msg1, &len);
+
+    PrlEvent_GetErrString(event, PRL_FALSE, PRL_FALSE, NULL, &len);
+
+    if (VIR_ALLOC_N(msg2, len) < 0)
+        goto cleanup;
+
+    PrlEvent_GetErrString(event, PRL_FALSE, PRL_FALSE, msg2, &len);
+
+    virReportErrorHelper(VIR_FROM_THIS, VIR_ERR_INTERNAL_ERROR,
+                         filename, funcname, linenr,
+                         _("%s %s"), msg1, msg2);
+    err = 0;
+
+ cleanup:
+    VIR_FREE(msg1);
+    VIR_FREE(msg2);
+
+    return err;
+}
+
+#define logPrlEventError(event)                    \
+    logPrlEventErrorHelper(event, __FILE__,        \
+                         __FUNCTION__, __LINE__)
+
+static PRL_HANDLE
+getJobResultHelper(PRL_HANDLE job, unsigned int timeout,
+                   const char *filename, const char *funcname,
+                   size_t linenr)
+{
+    PRL_RESULT ret, retCode;
+    PRL_HANDLE result = NULL;
+
+    if ((ret = PrlJob_Wait(job, timeout))) {
+        logPrlErrorHelper(ret, filename, funcname, linenr);
+        goto cleanup;
+    }
+
+    if ((ret = PrlJob_GetRetCode(job, &retCode))) {
+        logPrlErrorHelper(ret, filename, funcname, linenr);
+        goto cleanup;
+    }
+
+    if (retCode) {
+        PRL_HANDLE err_handle;
+
+        /* Sometimes it's possible to get additional error info. */
+        if ((ret = PrlJob_GetError(job, &err_handle))) {
+            logPrlErrorHelper(ret, filename, funcname, linenr);
+            goto cleanup;
+        }
+
+        if (logPrlEventErrorHelper(err_handle, filename, funcname, linenr))
+            logPrlErrorHelper(retCode, filename, funcname, linenr);
+
+        PrlHandle_Free(err_handle);
+    } else {
+        ret = PrlJob_GetResult(job, &result);
+        if (PRL_FAILED(ret)) {
+            logPrlErrorHelper(ret, filename, funcname, linenr);
+            PrlHandle_Free(result);
+            result = NULL;
+            goto cleanup;
+        }
+   }
+
+ cleanup:
+    PrlHandle_Free(job);
+    return result;
+}
+
+#define getJobResult(job, timeout)                  \
+    getJobResultHelper(job, timeout, __FILE__,      \
+                         __FUNCTION__, __LINE__)
+
+static int
+waitJobHelper(PRL_HANDLE job, unsigned int timeout,
+              const char *filename, const char *funcname,
+              size_t linenr)
+{
+    PRL_HANDLE result = NULL;
+
+    result = getJobResultHelper(job, timeout, filename, funcname, linenr);
+    if (result)
+        PrlHandle_Free(result);
+
+    return result ? 0 : -1;
+}
+
+#define waitJob(job, timeout)                  \
+    waitJobHelper(job, timeout, __FILE__,      \
+                         __FUNCTION__, __LINE__)
+
+int
+prlsdkInit(parallelsConnPtr privconn)
+{
+    PRL_RESULT ret;
+
+    ret = PrlApi_InitEx(PARALLELS_API_VER, PAM_SERVER, 0, 0);
+    if (PRL_FAILED(ret)) {
+        logPrlError(ret);
+        return -1;
+    }
+
+    privconn->jobTimeout = JOB_INFINIT_WAIT_TIMEOUT;
+
+    return 0;
+};
+
+void
+prlsdkDeinit(void)
+{
+    PrlApi_Deinit();
+};
+
+int
+prlsdkConnect(parallelsConnPtr privconn)
+{
+    PRL_RESULT ret;
+    PRL_HANDLE job = PRL_INVALID_HANDLE;
+
+    ret = PrlSrv_Create(&privconn->server);
+    if (PRL_FAILED(ret)) {
+        logPrlError(ret);
+        return -1;
+    }
+
+    job = PrlSrv_LoginLocalEx(privconn->server, NULL, 0,
+                              PSL_HIGH_SECURITY, PACF_NON_INTERACTIVE_MODE);
+
+    if (waitJob(job, privconn->jobTimeout)) {
+        PrlHandle_Free(privconn->server);
+        return -1;
+    }
+
+    return 0;
+}
+
+void
+prlsdkDisconnect(parallelsConnPtr privconn)
+{
+    PRL_HANDLE job;
+
+    job = PrlSrv_Logoff(privconn->server);
+    waitJob(job, privconn->jobTimeout);
+
+    PrlHandle_Free(privconn->server);
+}

diff --git a/src/parallels/parallels_sdk.h b/src/parallels/parallels_sdk.h
new file mode 100644 (file)
index 0000000..cefe67d
--- /dev/null
+++ b/src/parallels/parallels_sdk.h
@@ -0,0 +1,30 @@
+/*
+ * parallels_sdk.h: core driver functions for managing
+ * Parallels Cloud Server hosts
+ *
+ * Copyright (C) 2014 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, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <Parallels.h>
+
+#include "parallels_utils.h"
+
+int prlsdkInit(parallelsConnPtr privconn);
+void prlsdkDeinit(void);
+int prlsdkConnect(parallelsConnPtr privconn);
+void prlsdkDisconnect(parallelsConnPtr privconn);

diff --git a/src/parallels/parallels_utils.h b/src/parallels/parallels_utils.h
index 599e2c52580f4d774a3e011f7a05ea6963896980..aef590ff1223e1e4263158957dad780249a73979 100644 (file)
--- a/src/parallels/parallels_utils.h
+++ b/src/parallels/parallels_utils.h
@@ -23,6 +23,8 @@
 #ifndef PARALLELS_UTILS_H
 # define PARALLELS_UTILS_H
 
+# include <Parallels.h>
+
 # include "driver.h"
 # include "conf/domain_conf.h"
 # include "conf/storage_conf.h"
@@ -40,6 +42,8 @@
 struct _parallelsConn {
     virMutex lock;
     virDomainObjListPtr domains;
+    PRL_HANDLE server;
+    PRL_UINT32 jobTimeout;
     virStoragePoolObjList pools;
     virNetworkObjList networks;
     virCapsPtr caps;