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

[libvirt] [PATCH v2] esx: Add read-only storage pool access



Allows listing existing pools and requesting information about them.

Alter the esxVI_ProductVersion enum in a way that allows to check for
product type by masking.

Changes in v2:
 - split not directly related parts into separate patches
 - simplify goto usage: don't jump backwards
 - rework format of esxVI_ProductVersion values and explain the format
 - expand a FIXME in esxStoragePoolGetXMLDesc
---
 po/POTFILES.in                 |    1 +
 src/esx/esx_storage_driver.c   |  597 +++++++++++++++++++++++++++++++++++++++-
 src/esx/esx_vi.c               |  126 ++++++++-
 src/esx/esx_vi.h               |   33 ++-
 src/esx/esx_vi_generator.input |   59 ++++
 src/esx/esx_vi_generator.py    |    7 +-
 6 files changed, 794 insertions(+), 29 deletions(-)

diff --git a/po/POTFILES.in b/po/POTFILES.in
index 88218bd..e047b1b 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -19,6 +19,7 @@ src/cpu/cpu_map.c
 src/cpu/cpu_x86.c
 src/datatypes.c
 src/esx/esx_driver.c
+src/esx/esx_storage_driver.c
 src/esx/esx_util.c
 src/esx/esx_vi.c
 src/esx/esx_vi_methods.c
diff --git a/src/esx/esx_storage_driver.c b/src/esx/esx_storage_driver.c
index 97b92a5..0e2e1a3 100644
--- a/src/esx/esx_storage_driver.c
+++ b/src/esx/esx_storage_driver.c
@@ -29,6 +29,7 @@
 #include "memory.h"
 #include "logging.h"
 #include "uuid.h"
+#include "storage_conf.h"
 #include "esx_private.h"
 #include "esx_storage_driver.h"
 #include "esx_vi.h"
@@ -65,17 +66,587 @@ esxStorageClose(virConnectPtr conn)
 
 
 
+static int
+esxNumberOfStoragePools(virConnectPtr conn)
+{
+    int count = 0;
+    esxPrivate *priv = conn->storagePrivateData;
+    esxVI_ObjectContent *datastoreList = NULL;
+    esxVI_ObjectContent *datastore = NULL;
+
+    if (esxVI_EnsureSession(priv->host) < 0) {
+        return -1;
+    }
+
+    if (esxVI_LookupObjectContentByType(priv->host, priv->host->datacenter,
+                                        "Datastore", NULL, esxVI_Boolean_True,
+                                        &datastoreList) < 0) {
+        return -1;
+    }
+
+    for (datastore = datastoreList; datastore != NULL;
+         datastore = datastore->_next) {
+        ++count;
+    }
+
+    esxVI_ObjectContent_Free(&datastoreList);
+
+    return count;
+}
+
+
+
+static int
+esxListStoragePools(virConnectPtr conn, char **const names, int maxnames)
+{
+    bool success = false;
+    esxPrivate *priv = conn->storagePrivateData;
+    esxVI_String *propertyNameList = NULL;
+    esxVI_DynamicProperty *dynamicProperty = NULL;
+    esxVI_ObjectContent *datastoreList = NULL;
+    esxVI_ObjectContent *datastore = NULL;
+    int count = 0;
+    int i;
+
+    if (names == NULL || maxnames < 0) {
+        ESX_ERROR(VIR_ERR_INVALID_ARG, "%s", _("Invalid argument"));
+        return -1;
+    }
+
+    if (maxnames == 0) {
+        return 0;
+    }
+
+    if (esxVI_EnsureSession(priv->host) < 0) {
+        return -1;
+    }
+
+    if (esxVI_String_AppendValueToList(&propertyNameList,
+                                       "summary.name") < 0 ||
+        esxVI_LookupObjectContentByType(priv->host, priv->host->datacenter,
+                                        "Datastore", propertyNameList,
+                                        esxVI_Boolean_True,
+                                        &datastoreList) < 0) {
+        goto cleanup;
+    }
+
+    for (datastore = datastoreList; datastore != NULL;
+         datastore = datastore->_next) {
+        for (dynamicProperty = datastore->propSet; dynamicProperty != NULL;
+             dynamicProperty = dynamicProperty->_next) {
+            if (STREQ(dynamicProperty->name, "summary.name")) {
+                if (esxVI_AnyType_ExpectType(dynamicProperty->val,
+                                             esxVI_Type_String) < 0) {
+                    goto cleanup;
+                }
+
+                names[count] = strdup(dynamicProperty->val->string);
+
+                if (names[count] == NULL) {
+                    virReportOOMError();
+                    goto cleanup;
+                }
+
+                ++count;
+                break;
+            } else {
+                VIR_WARN("Unexpected '%s' property", dynamicProperty->name);
+            }
+        }
+    }
+
+    success = true;
+
+  cleanup:
+    if (! success) {
+        for (i = 0; i < count; ++i) {
+            VIR_FREE(names[i]);
+        }
+
+        count = -1;
+    }
+
+    esxVI_String_Free(&propertyNameList);
+    esxVI_ObjectContent_Free(&datastoreList);
+
+    return count;
+}
+
+
+
+static int
+esxNumberOfDefinedStoragePools(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+    /* ESX storage pools are always active */
+    return 0;
+}
+
+
+
+static int
+esxListDefinedStoragePools(virConnectPtr conn ATTRIBUTE_UNUSED,
+                           char **const names ATTRIBUTE_UNUSED,
+                           int maxnames ATTRIBUTE_UNUSED)
+{
+    /* ESX storage pools are always active */
+    return 0;
+}
+
+
+
+static virStoragePoolPtr
+esxStoragePoolLookupByName(virConnectPtr conn, const char *name)
+{
+    esxPrivate *priv = conn->storagePrivateData;
+    esxVI_String *propertyNameList = NULL;
+    esxVI_ObjectContent *datastore = NULL;
+    esxVI_Boolean accessible = esxVI_Boolean_Undefined;
+    char *summaryUrl = NULL;
+    char *suffix = NULL;
+    int suffixLength;
+    char uuid_string[VIR_UUID_STRING_BUFLEN] = "00000000-00000000-0000-000000000000";
+    unsigned char uuid[VIR_UUID_BUFLEN];
+    char *realName = NULL;
+    virStoragePoolPtr pool = NULL;
+
+    if (esxVI_EnsureSession(priv->host) < 0) {
+        return NULL;
+    }
+
+    if (esxVI_String_AppendValueListToList(&propertyNameList,
+                                           "summary.accessible\0"
+                                           "summary.name\0"
+                                           "summary.url\0") < 0 ||
+        esxVI_LookupDatastoreByName(priv->host, name,
+                                    propertyNameList, &datastore,
+                                    esxVI_Occurrence_RequiredItem) < 0 ||
+        esxVI_GetBoolean(datastore, "summary.accessible",
+                         &accessible, esxVI_Occurrence_RequiredItem) < 0) {
+        goto cleanup;
+    }
+
+    /*
+     * Datastores don't have a UUID. We can use the 'summary.url' property as
+     * source for a "UUID" on ESX, because the property value has this format:
+     *
+     *   summary.url = /vmfs/volumes/4b0beca7-7fd401f3-1d7f-000ae484a6a3
+     *   summary.url = /vmfs/volumes/b24b7a78-9d82b4f5    (short format)
+     *
+     * The 'summary.url' property comes in two forms, with a complete "UUID"
+     * and a short "UUID".
+     *
+     * But this trailing "UUID" is not guaranteed to be there. On the other
+     * hand we already rely on another implementation detail of the ESX server:
+     * The object name of virtual machine contains an integer, we use that as
+     * domain ID.
+     *
+     * The 'summary.url' property of an inaccessible datastore is invalid.
+     */
+    if (accessible == esxVI_Boolean_True &&
+        priv->host->productVersion & esxVI_ProductVersion_ESX) {
+        if (esxVI_GetStringValue(datastore, "summary.url", &summaryUrl,
+                                 esxVI_Occurrence_RequiredItem) < 0) {
+            goto cleanup;
+        }
+
+        if ((suffix = STRSKIP(summaryUrl, "/vmfs/volumes/")) == NULL) {
+            ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR,
+                         _("Datastore URL '%s' has unexpected prefix, "
+                           "expecting '/vmfs/volumes/' prefix"), summaryUrl);
+            goto cleanup;
+        }
+
+        suffixLength = strlen(suffix);
+
+        if ((suffixLength == 35 && /* = strlen("4b0beca7-7fd401f3-1d7f-000ae484a6a3") */
+             suffix[8] == '-' && suffix[17] == '-' && suffix[22] == '-') ||
+            (suffixLength == 17 && /* = strlen("b24b7a78-9d82b4f5") */
+             suffix[8] == '-')) {
+            /*
+             * Intentionally use memcpy here, because we want to be able to
+             * replace a prefix of the initial Zero-UUID. virStrncpy would
+             * null-terminate the string in an unwanted place.
+             */
+            memcpy(uuid_string, suffix, suffixLength);
+        } else {
+            VIR_WARN("Datastore URL suffix '%s' has unexpected format, "
+                     "cannot deduce a UUID from it", suffix);
+        }
+    }
+
+    if (virUUIDParse(uuid_string, uuid) < 0) {
+        ESX_ERROR(VIR_ERR_INTERNAL_ERROR,
+                  _("Could not parse UUID from string '%s'"),
+                  uuid_string);
+        goto cleanup;
+    }
+
+    if (esxVI_GetStringValue(datastore, "summary.name", &realName,
+                             esxVI_Occurrence_RequiredItem) < 0) {
+        goto cleanup;
+    }
+
+    pool = virGetStoragePool(conn, realName, uuid);
+
+  cleanup:
+    esxVI_String_Free(&propertyNameList);
+    esxVI_ObjectContent_Free(&datastore);
+
+    return pool;
+}
+
+
+
+static virStoragePoolPtr
+esxStoragePoolLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
+{
+    esxPrivate *priv = conn->storagePrivateData;
+    esxVI_String *propertyNameList = NULL;
+    esxVI_ObjectContent *datastore = NULL;
+    char uuid_string[VIR_UUID_STRING_BUFLEN] = "";
+    char *name = NULL;
+    virStoragePoolPtr pool = NULL;
+
+    if (! (priv->host->productVersion & esxVI_ProductVersion_ESX)) {
+        ESX_ERROR(VIR_ERR_INTERNAL_ERROR, "%s",
+                  _("Lookup by UUID is supported on ESX only"));
+        return NULL;
+    }
+
+    if (esxVI_EnsureSession(priv->host) < 0) {
+        return NULL;
+    }
+
+    /*
+     * Convert from UUID to datastore URL form by stripping the second '-':
+     *
+     * <---- 14 ----><-------- 22 -------->    <---- 13 ---><-------- 22 -------->
+     * 4b0beca7-7fd4-01f3-1d7f-000ae484a6a3 -> 4b0beca7-7fd401f3-1d7f-000ae484a6a3
+     */
+    virUUIDFormat(uuid, uuid_string);
+    memmove(uuid_string + 13, uuid_string + 14, 22 + 1);
+
+    /*
+     * Use esxVI_LookupDatastoreByName because it also does try to match "UUID"
+     * part of the 'summary.url' property if there is no name match.
+     */
+    if (esxVI_String_AppendValueToList(&propertyNameList, "summary.name") < 0 ||
+        esxVI_LookupDatastoreByName(priv->host, uuid_string,
+                                    propertyNameList, &datastore,
+                                    esxVI_Occurrence_OptionalItem) < 0) {
+        goto cleanup;
+    }
+
+    /*
+     * If the first try didn't succeed and the trailing 16 digits are zero then
+     * the "UUID" could be a short one. Strip the 16 zeros and try again:
+     *
+     * <------ 17 ----->                      <------ 17 ----->
+     * b24b7a78-9d82b4f5-0000-000000000000 -> b24b7a78-9d82b4f5
+     */
+    if (datastore == NULL && STREQ(uuid_string + 17, "-0000-000000000000")) {
+        uuid_string[17] = '\0';
+
+        if (esxVI_LookupDatastoreByName(priv->host, uuid_string,
+                                        propertyNameList, &datastore,
+                                        esxVI_Occurrence_RequiredItem) < 0) {
+            goto cleanup;
+        }
+    }
+
+    if (datastore == NULL) {
+        virUUIDFormat(uuid, uuid_string);
+
+        ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR,
+                     _("Could not find datastore with UUID '%s'"),
+                     uuid_string);
+
+        goto cleanup;
+    }
+
+    if (esxVI_GetStringValue(datastore, "summary.name", &name,
+                             esxVI_Occurrence_RequiredItem) < 0) {
+        goto cleanup;
+    }
+
+    pool = virGetStoragePool(conn, name, uuid);
+
+  cleanup:
+    esxVI_String_Free(&propertyNameList);
+    esxVI_ObjectContent_Free(&datastore);
+
+    return pool;
+}
+
+
+
+static int
+esxStoragePoolRefresh(virStoragePoolPtr pool, unsigned int flags)
+{
+    int result = -1;
+    esxPrivate *priv = pool->conn->storagePrivateData;
+    esxVI_ObjectContent *datastore = NULL;
+
+    virCheckFlags(0, -1);
+
+    if (esxVI_EnsureSession(priv->host) < 0) {
+        return -1;
+    }
+
+    if (esxVI_LookupDatastoreByName(priv->host, pool->name, NULL, &datastore,
+                                    esxVI_Occurrence_RequiredItem) < 0 ||
+        esxVI_RefreshDatastore(priv->host, datastore->obj) < 0) {
+        goto cleanup;
+    }
+
+    result = 0;
+
+  cleanup:
+    esxVI_ObjectContent_Free(&datastore);
+
+    return result;
+}
+
+
+
+static int
+esxStoragePoolGetInfo(virStoragePoolPtr pool, virStoragePoolInfoPtr info)
+{
+    int result = -1;
+    esxPrivate *priv = pool->conn->storagePrivateData;
+    esxVI_String *propertyNameList = NULL;
+    esxVI_ObjectContent *datastore = NULL;
+    esxVI_DynamicProperty *dynamicProperty = NULL;
+    esxVI_Boolean accessible = esxVI_Boolean_Undefined;
+
+    memset(info, 0, sizeof (*info));
+
+    if (esxVI_EnsureSession(priv->host) < 0) {
+        return -1;
+    }
+
+    if (esxVI_String_AppendValueListToList(&propertyNameList,
+                                           "summary.accessible\0"
+                                           "summary.capacity\0"
+                                           "summary.freeSpace\0") < 0 ||
+        esxVI_LookupDatastoreByName(priv->host, pool->name,
+                                    propertyNameList, &datastore,
+                                    esxVI_Occurrence_RequiredItem) < 0 ||
+        esxVI_GetBoolean(datastore, "summary.accessible",
+                         &accessible, esxVI_Occurrence_RequiredItem) < 0) {
+        goto cleanup;
+    }
+
+    if (accessible == esxVI_Boolean_True) {
+        info->state = VIR_STORAGE_POOL_RUNNING;
+
+        for (dynamicProperty = datastore->propSet; dynamicProperty != NULL;
+             dynamicProperty = dynamicProperty->_next) {
+            if (STREQ(dynamicProperty->name, "summary.capacity")) {
+                if (esxVI_AnyType_ExpectType(dynamicProperty->val,
+                                             esxVI_Type_Long) < 0) {
+                    goto cleanup;
+                }
+
+                info->capacity = dynamicProperty->val->int64;
+            } else if (STREQ(dynamicProperty->name, "summary.freeSpace")) {
+                if (esxVI_AnyType_ExpectType(dynamicProperty->val,
+                                             esxVI_Type_Long) < 0) {
+                    goto cleanup;
+                }
+
+                info->available = dynamicProperty->val->int64;
+            }
+        }
+
+        info->allocation = info->capacity - info->available;
+    } else {
+        info->state = VIR_STORAGE_POOL_INACCESSIBLE;
+    }
+
+    result = 0;
+
+  cleanup:
+    if (result < 0) {
+        memset(info, 0, sizeof (*info));
+    }
+
+    esxVI_String_Free(&propertyNameList);
+    esxVI_ObjectContent_Free(&datastore);
+
+    return result;
+}
+
+
+
+static char *
+esxStoragePoolGetXMLDesc(virStoragePoolPtr pool, unsigned int flags)
+{
+    esxPrivate *priv = pool->conn->storagePrivateData;
+    esxVI_String *propertyNameList = NULL;
+    esxVI_ObjectContent *datastore = NULL;
+    esxVI_DynamicProperty *dynamicProperty = NULL;
+    esxVI_Boolean accessible = esxVI_Boolean_Undefined;
+    virStoragePoolDef def;
+    esxVI_DatastoreInfo *info = NULL;
+    esxVI_LocalDatastoreInfo *localInfo = NULL;
+    esxVI_NasDatastoreInfo *nasInfo = NULL;
+    esxVI_VmfsDatastoreInfo *vmfsInfo = NULL;
+    char *xml = NULL;
+
+    virCheckFlags(0, NULL);
+
+    memset(&def, 0, sizeof (def));
+
+    if (esxVI_EnsureSession(priv->host) < 0) {
+        return NULL;
+    }
+
+    if (esxVI_String_AppendValueListToList(&propertyNameList,
+                                           "summary.accessible\0"
+                                           "summary.capacity\0"
+                                           "summary.freeSpace\0"
+                                           "info\0") < 0 ||
+        esxVI_LookupDatastoreByName(priv->host, pool->name,
+                                    propertyNameList, &datastore,
+                                    esxVI_Occurrence_RequiredItem) < 0 ||
+        esxVI_GetBoolean(datastore, "summary.accessible",
+                         &accessible, esxVI_Occurrence_RequiredItem) < 0) {
+        goto cleanup;
+    }
+
+    def.name = pool->name;
+    memcpy(def.uuid, pool->uuid, VIR_UUID_BUFLEN);
+
+    if (accessible == esxVI_Boolean_True) {
+        for (dynamicProperty = datastore->propSet; dynamicProperty != NULL;
+             dynamicProperty = dynamicProperty->_next) {
+            if (STREQ(dynamicProperty->name, "summary.capacity")) {
+                if (esxVI_AnyType_ExpectType(dynamicProperty->val,
+                                             esxVI_Type_Long) < 0) {
+                    goto cleanup;
+                }
+
+                def.capacity = dynamicProperty->val->int64;
+            } else if (STREQ(dynamicProperty->name, "summary.freeSpace")) {
+                if (esxVI_AnyType_ExpectType(dynamicProperty->val,
+                                             esxVI_Type_Long) < 0) {
+                    goto cleanup;
+                }
+
+                def.available = dynamicProperty->val->int64;
+            } else if (STREQ(dynamicProperty->name, "info")) {
+                if (esxVI_DatastoreInfo_CastFromAnyType(dynamicProperty->val,
+                                                        &info) < 0) {
+                    goto cleanup;
+                }
+            }
+        }
+
+        def.allocation = def.capacity - def.available;
+
+        /* See vSphere API documentation about HostDatastoreSystem for details */
+        if ((localInfo = esxVI_LocalDatastoreInfo_DynamicCast(info)) != NULL) {
+            def.type = VIR_STORAGE_POOL_DIR;
+            def.target.path = localInfo->path;
+        } else if ((nasInfo = esxVI_NasDatastoreInfo_DynamicCast(info)) != NULL) {
+            def.type = VIR_STORAGE_POOL_NETFS;
+            def.source.host.name = nasInfo->nas->remoteHost;
+            def.source.dir = nasInfo->nas->remotePath;
+
+            if (STRCASEEQ(nasInfo->nas->type, "NFS")) {
+                def.source.format = VIR_STORAGE_POOL_NETFS_NFS;
+            } else  if (STRCASEEQ(nasInfo->nas->type, "CIFS")) {
+                def.source.format = VIR_STORAGE_POOL_NETFS_CIFS;
+            } else {
+                ESX_ERROR(VIR_ERR_INTERNAL_ERROR,
+                          _("Datastore has unexpected type '%s'"),
+                          nasInfo->nas->type);
+                goto cleanup;
+            }
+        } else if ((vmfsInfo = esxVI_VmfsDatastoreInfo_DynamicCast(info)) != NULL) {
+            def.type = VIR_STORAGE_POOL_FS;
+            /*
+             * FIXME: I'm not sure how to represent the source and target of a
+             * VMFS based datastore in libvirt terms
+             */
+        } else {
+            ESX_ERROR(VIR_ERR_INTERNAL_ERROR, "%s",
+                      _("DatastoreInfo has unexpected type"));
+            goto cleanup;
+        }
+    }
+
+    xml = virStoragePoolDefFormat(&def);
+
+  cleanup:
+    esxVI_String_Free(&propertyNameList);
+    esxVI_ObjectContent_Free(&datastore);
+    esxVI_DatastoreInfo_Free(&info);
+
+    return xml;
+}
+
+
+
+static int
+esxStoragePoolGetAutostart(virStoragePoolPtr pool ATTRIBUTE_UNUSED,
+                           int *autostart)
+{
+    /* ESX storage pools are always active */
+    *autostart = 1;
+
+    return 0;
+}
+
+
+
+static int
+esxStoragePoolSetAutostart(virStoragePoolPtr pool ATTRIBUTE_UNUSED,
+                           int autostart)
+{
+    /* Just accept autostart activation, but fail on autostart deactivation */
+    autostart = (autostart != 0);
+
+    if (! autostart) {
+        ESX_ERROR(VIR_ERR_INTERNAL_ERROR, "%s",
+                  _("Cannot deactivate storage pool autostart"));
+        return -1;
+    }
+
+    return 0;
+}
+
+
+
+static int
+esxStoragePoolIsActive(virStoragePoolPtr pool ATTRIBUTE_UNUSED)
+{
+    /* ESX storage pools are always active */
+    return 1;
+}
+
+
+
+static int
+esxStoragePoolIsPersistent(virStoragePoolPtr pool ATTRIBUTE_UNUSED)
+{
+    /* ESX has no concept of transient pools, so all of them are persistent */
+    return 1;
+}
+
+
 static virStorageDriver esxStorageDriver = {
     "ESX",                                 /* name */
     esxStorageOpen,                        /* open */
     esxStorageClose,                       /* close */
-    NULL,                                  /* numOfPools */
-    NULL,                                  /* listPools */
-    NULL,                                  /* numOfDefinedPools */
-    NULL,                                  /* listDefinedPools */
+    esxNumberOfStoragePools,               /* numOfPools */
+    esxListStoragePools,                   /* listPools */
+    esxNumberOfDefinedStoragePools,        /* numOfDefinedPools */
+    esxListDefinedStoragePools,            /* listDefinedPools */
     NULL,                                  /* findPoolSources */
-    NULL,                                  /* poolLookupByName */
-    NULL,                                  /* poolLookupByUUID */
+    esxStoragePoolLookupByName,            /* poolLookupByName */
+    esxStoragePoolLookupByUUID,            /* poolLookupByUUID */
     NULL,                                  /* poolLookupByVolume */
     NULL,                                  /* poolCreateXML */
     NULL,                                  /* poolDefineXML */
@@ -84,11 +655,11 @@ static virStorageDriver esxStorageDriver = {
     NULL,                                  /* poolCreate */
     NULL,                                  /* poolDestroy */
     NULL,                                  /* poolDelete */
-    NULL,                                  /* poolRefresh */
-    NULL,                                  /* poolGetInfo */
-    NULL,                                  /* poolGetXMLDesc */
-    NULL,                                  /* poolGetAutostart */
-    NULL,                                  /* poolSetAutostart */
+    esxStoragePoolRefresh,                 /* poolRefresh */
+    esxStoragePoolGetInfo,                 /* poolGetInfo */
+    esxStoragePoolGetXMLDesc,              /* poolGetXMLDesc */
+    esxStoragePoolGetAutostart,            /* poolGetAutostart */
+    esxStoragePoolSetAutostart,            /* poolSetAutostart */
     NULL,                                  /* poolNumOfVolumes */
     NULL,                                  /* poolListVolumes */
     NULL,                                  /* volLookupByName */
@@ -101,8 +672,8 @@ static virStorageDriver esxStorageDriver = {
     NULL,                                  /* volGetInfo */
     NULL,                                  /* volGetXMLDesc */
     NULL,                                  /* volGetPath */
-    NULL,                                  /* poolIsActive */
-    NULL,                                  /* poolIsPersistent */
+    esxStoragePoolIsActive,                /* poolIsActive */
+    esxStoragePoolIsPersistent,            /* poolIsPersistent */
 };
 
 
diff --git a/src/esx/esx_vi.c b/src/esx/esx_vi.c
index 966ef85..100b9d2 100644
--- a/src/esx/esx_vi.c
+++ b/src/esx/esx_vi.c
@@ -1530,6 +1530,114 @@ esxVI_GetVirtualMachineQuestionInfo
 
 
 int
+esxVI_GetBoolean(esxVI_ObjectContent *objectContent, const char *propertyName,
+                 esxVI_Boolean *value, esxVI_Occurrence occurence)
+{
+    esxVI_DynamicProperty *dynamicProperty;
+
+    if (value == NULL || *value != esxVI_Boolean_Undefined) {
+        ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, "%s", _("Invalid argument"));
+        return -1;
+    }
+
+    for (dynamicProperty = objectContent->propSet; dynamicProperty != NULL;
+         dynamicProperty = dynamicProperty->_next) {
+        if (STREQ(dynamicProperty->name, propertyName)) {
+            if (esxVI_AnyType_ExpectType(dynamicProperty->val,
+                                         esxVI_Type_Boolean) < 0) {
+                return -1;
+            }
+
+            *value = dynamicProperty->val->boolean;
+            break;
+        }
+    }
+
+    if (*value == esxVI_Boolean_Undefined &&
+        occurence == esxVI_Occurrence_RequiredItem) {
+        ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR,
+                     _("Missing '%s' property"), propertyName);
+        return -1;
+    }
+
+    return 0;
+}
+
+
+
+int
+esxVI_GetStringValue(esxVI_ObjectContent *objectContent,
+                     const char *propertyName,
+                     char **value, esxVI_Occurrence occurence)
+{
+    esxVI_DynamicProperty *dynamicProperty;
+
+    if (value == NULL || *value != NULL) {
+        ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, "%s", _("Invalid argument"));
+        return -1;
+    }
+
+    for (dynamicProperty = objectContent->propSet; dynamicProperty != NULL;
+         dynamicProperty = dynamicProperty->_next) {
+        if (STREQ(dynamicProperty->name, propertyName)) {
+            if (esxVI_AnyType_ExpectType(dynamicProperty->val,
+                                         esxVI_Type_String) < 0) {
+                return -1;
+            }
+
+            *value = dynamicProperty->val->string;
+            break;
+        }
+    }
+
+    if (*value == NULL && occurence == esxVI_Occurrence_RequiredItem) {
+        ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR,
+                     _("Missing '%s' property"), propertyName);
+        return -1;
+    }
+
+    return 0;
+}
+
+
+
+int
+esxVI_GetManagedObjectReference(esxVI_ObjectContent *objectContent,
+                                const char *propertyName,
+                                esxVI_ManagedObjectReference **value,
+                                esxVI_Occurrence occurence)
+{
+    esxVI_DynamicProperty *dynamicProperty;
+
+    if (value == NULL || *value != NULL) {
+        ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, "%s", _("Invalid argument"));
+        return -1;
+    }
+
+    for (dynamicProperty = objectContent->propSet; dynamicProperty != NULL;
+         dynamicProperty = dynamicProperty->_next) {
+        if (STREQ(dynamicProperty->name, propertyName)) {
+            if (esxVI_ManagedObjectReference_CastFromAnyType
+                  (dynamicProperty->val, value) < 0) {
+                return -1;
+            }
+
+            break;
+        }
+    }
+
+    if (*value == NULL && occurence == esxVI_Occurrence_RequiredItem) {
+        ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR,
+                     _("Missing '%s' property"), propertyName);
+        return -1;
+    }
+
+    return 0;
+}
+
+
+
+int
 esxVI_LookupNumberOfDomainsByPowerState(esxVI_Context *ctx,
                                         esxVI_VirtualMachinePowerState powerState,
                                         esxVI_Boolean inverse)
@@ -2161,7 +2269,7 @@ esxVI_LookupDatastoreByName(esxVI_Context *ctx, const char *name,
     esxVI_ObjectContent *candidate = NULL;
     esxVI_DynamicProperty *dynamicProperty = NULL;
     esxVI_Boolean accessible = esxVI_Boolean_Undefined;
-    size_t offset = strlen("/vmfs/volumes/");
+    size_t offset = 14; /* = strlen("/vmfs/volumes/") */
     int numInaccessibleDatastores = 0;
 
     if (datastore == NULL || *datastore != NULL) {
@@ -2227,9 +2335,7 @@ esxVI_LookupDatastoreByName(esxVI_Context *ctx, const char *name,
 
         for (dynamicProperty = candidate->propSet; dynamicProperty != NULL;
              dynamicProperty = dynamicProperty->_next) {
-            if (STREQ(dynamicProperty->name, "summary.accessible")) {
-                /* Ignore it */
-            } else if (STREQ(dynamicProperty->name, "summary.name")) {
+            if (STREQ(dynamicProperty->name, "summary.name")) {
                 if (esxVI_AnyType_ExpectType(dynamicProperty->val,
                                              esxVI_Type_String) < 0) {
                     goto failure;
@@ -2244,7 +2350,8 @@ esxVI_LookupDatastoreByName(esxVI_Context *ctx, const char *name,
                     /* Found datastore with matching name */
                     goto cleanup;
                 }
-            } else if (STREQ(dynamicProperty->name, "summary.url")) {
+            } else if (STREQ(dynamicProperty->name, "summary.url") &&
+                       ctx->productVersion & esxVI_ProductVersion_ESX) {
                 if (accessible == esxVI_Boolean_False) {
                     /*
                      * The 'summary.url' property of an inaccessible datastore
@@ -2276,8 +2383,6 @@ esxVI_LookupDatastoreByName(esxVI_Context *ctx, const char *name,
                     /* Found datastore with matching URL suffix */
                     goto cleanup;
                 }
-            } else {
-                VIR_WARN("Unexpected '%s' property", dynamicProperty->name);
             }
         }
     }
@@ -2309,9 +2414,10 @@ esxVI_LookupDatastoreByName(esxVI_Context *ctx, const char *name,
 
 
 
-int esxVI_LookupTaskInfoByTask(esxVI_Context *ctx,
-                               esxVI_ManagedObjectReference *task,
-                               esxVI_TaskInfo **taskInfo)
+int
+esxVI_LookupTaskInfoByTask(esxVI_Context *ctx,
+                           esxVI_ManagedObjectReference *task,
+                           esxVI_TaskInfo **taskInfo)
 {
     int result = 0;
     esxVI_String *propertyNameList = NULL;
diff --git a/src/esx/esx_vi.h b/src/esx/esx_vi.h
index d581a59..e2687c4 100644
--- a/src/esx/esx_vi.h
+++ b/src/esx/esx_vi.h
@@ -96,13 +96,23 @@ enum _esxVI_APIVersion {
     esxVI_APIVersion_40
 };
 
+/*
+ * AAAABBBB: where AAAA0000 is the product and BBBB the version. this format
+ * allows simple bitmask testing for a product independent of the version
+ */
 enum _esxVI_ProductVersion {
     esxVI_ProductVersion_Undefined = 0,
-    esxVI_ProductVersion_GSX20,
-    esxVI_ProductVersion_ESX35,
-    esxVI_ProductVersion_ESX40,
-    esxVI_ProductVersion_VPX25,
-    esxVI_ProductVersion_VPX40
+
+    esxVI_ProductVersion_GSX   = (1 << 0) << 16,
+    esxVI_ProductVersion_GSX20 = esxVI_ProductVersion_GSX | 1,
+
+    esxVI_ProductVersion_ESX   = (1 << 1) << 16,
+    esxVI_ProductVersion_ESX35 = esxVI_ProductVersion_ESX | 1,
+    esxVI_ProductVersion_ESX40 = esxVI_ProductVersion_ESX | 2,
+
+    esxVI_ProductVersion_VPX   = (1 << 2) << 16,
+    esxVI_ProductVersion_VPX25 = esxVI_ProductVersion_VPX | 1,
+    esxVI_ProductVersion_VPX40 = esxVI_ProductVersion_VPX | 2
 };
 
 enum _esxVI_Occurrence {
@@ -272,6 +282,19 @@ int esxVI_GetVirtualMachineQuestionInfo
       (esxVI_ObjectContent *virtualMachine,
        esxVI_VirtualMachineQuestionInfo **questionInfo);
 
+int esxVI_GetBoolean(esxVI_ObjectContent *objectContent,
+                     const char *propertyName,
+                     esxVI_Boolean *value, esxVI_Occurrence occurence);
+
+int esxVI_GetStringValue(esxVI_ObjectContent *objectContent,
+                         const char *propertyName,
+                         char **value, esxVI_Occurrence occurence);
+
+int esxVI_GetManagedObjectReference(esxVI_ObjectContent *objectContent,
+                                    const char *propertyName,
+                                    esxVI_ManagedObjectReference **value,
+                                    esxVI_Occurrence occurence);
+
 int esxVI_LookupNumberOfDomainsByPowerState
       (esxVI_Context *ctx, esxVI_VirtualMachinePowerState powerState,
        esxVI_Boolean inverse);
diff --git a/src/esx/esx_vi_generator.input b/src/esx/esx_vi_generator.input
index 5e5e6ba..ff65178 100644
--- a/src/esx/esx_vi_generator.input
+++ b/src/esx/esx_vi_generator.input
@@ -146,6 +146,14 @@ object ChoiceOption extends OptionType
 end
 
 
+object DatastoreInfo
+    String                                   name                           r
+    String                                   url                            r
+    Long                                     freeSpace                      r
+    Long                                     maxFileSize                    r
+end
+
+
 object Description
     String                                   label                          r
     String                                   summary                        r
@@ -186,6 +194,47 @@ object HostCpuIdInfo
 end
 
 
+object HostFileSystemVolume
+    String                                   type                           r
+    String                                   name                           r
+    Long                                     capacity                       r
+end
+
+
+object HostNasVolume extends HostFileSystemVolume
+    String                                   remoteHost                     r
+    String                                   remotePath                     r
+    String                                   userName                       o
+end
+
+
+object HostScsiDiskPartition
+    String                                   diskName                       r
+    Int                                      partition                      r
+end
+
+
+object HostVmfsVolume extends HostFileSystemVolume
+    Int                                      blockSizeMb                    r
+    Int                                      maxBlocks                      r
+    Int                                      majorVersion                   r
+    String                                   version                        r
+    String                                   uuid                           r
+    HostScsiDiskPartition                    extent                         rl
+    Boolean                                  vmfsUpgradable                 r
+end
+
+
+object LocalDatastoreInfo extends DatastoreInfo
+    String                                   path                           o
+end
+
+
+object NasDatastoreInfo extends DatastoreInfo
+    HostNasVolume                            nas                            o
+end
+
+
 object ObjectContent
     ManagedObjectReference                   obj                            r
     DynamicProperty                          propSet                        ol
@@ -453,6 +502,11 @@ object VirtualMachineSnapshotTree
 end
 
 
+object VmfsDatastoreInfo extends DatastoreInfo
+    HostVmfsVolume                           vmfs                           o
+end
+
+
 # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
 # Methods
 #
@@ -571,6 +625,11 @@ method ReconfigVM_Task returns ManagedObjectReference r
 end
 
 
+method RefreshDatastore
+    ManagedObjectReference                   _this                          r
+end
+
+
 method RegisterVM_Task returns ManagedObjectReference r
     ManagedObjectReference                   _this                          r
     String                                   path                           r
diff --git a/src/esx/esx_vi_generator.py b/src/esx/esx_vi_generator.py
index 6ae13c0..8df0e80 100755
--- a/src/esx/esx_vi_generator.py
+++ b/src/esx/esx_vi_generator.py
@@ -382,6 +382,9 @@ class Object:
         self.properties = properties
         self.extended_by = extended_by
 
+        if self.extended_by is not None:
+            self.extended_by.sort();
+
 
     def generate_struct_members(self, add_banner = False, struct_gap = False):
         global objects_by_name
@@ -1095,7 +1098,8 @@ additional_enum_features = { "ManagedEntityStatus"      : Enum.FEATURE__ANY_TYPE
                              "VirtualMachinePowerState" : Enum.FEATURE__ANY_TYPE }
 
 
-additional_object_features = { "Event"                      : Object.FEATURE__LIST,
+additional_object_features = { "DatastoreInfo"              : Object.FEATURE__ANY_TYPE | Object.FEATURE__DYNAMIC_CAST,
+                               "Event"                      : Object.FEATURE__LIST,
                                "HostCpuIdInfo"              : Object.FEATURE__ANY_TYPE | Object.FEATURE__LIST,
                                "ManagedObjectReference"     : Object.FEATURE__ANY_TYPE,
                                "ObjectContent"              : Object.FEATURE__DEEP_COPY | Object.FEATURE__LIST,
@@ -1235,6 +1239,7 @@ for obj in objects_by_name.values():
             extended_obj.extended_by = [obj.name]
         else:
             extended_obj.extended_by.append(obj.name)
+            extended_obj.extended_by.sort()
 
 
 
-- 
1.7.0.4


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