The Python script generates the mappings based on the type descriptions in the esx_vi_generator.input file. This also improves the inheritance handling and allows to get rid of the ugly, inflexible, and error prone _base/_super approach. Now every struct that represents a SOAP type contains a _type member, that allows to recreate C++-like dynamic dispatch for "method" calls in C. --- src/Makefile.am | 23 +- src/esx/.gitignore | 1 + src/esx/esx_driver.c | 10 +- src/esx/esx_vi.c | 51 +- src/esx/esx_vi.h | 7 +- src/esx/esx_vi_generator.input | 426 ++++++++ src/esx/esx_vi_generator.py | 1025 ++++++++++++++++++ src/esx/esx_vi_methods.c | 44 +- src/esx/esx_vi_types.c | 2258 +++++----------------------------------- src/esx/esx_vi_types.h | 1090 +------------------- 10 files changed, 1868 insertions(+), 3067 deletions(-) create mode 100644 src/esx/.gitignore create mode 100644 src/esx/esx_vi_generator.input create mode 100755 src/esx/esx_vi_generator.py diff --git a/src/Makefile.am b/src/Makefile.am index c661a5c..54792b4 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -26,6 +26,8 @@ INCLUDES = \ EXTRA_DIST = $(conf_DATA) +BUILT_SOURCES = + if WITH_NETWORK UUID=$(shell uuidgen 2>/dev/null) endif @@ -250,6 +252,20 @@ ESX_DRIVER_SOURCES = \ esx/esx_vi_types.c esx/esx_vi_types.h \ esx/esx_vmx.c esx/esx_vmx.h +ESX_DRIVER_GENERATED = \ + esx/esx_vi_types.generated.c \ + esx/esx_vi_types.generated.h \ + esx/esx_vi_types.generated.typedef \ + esx/esx_vi_types.generated.typeenum \ + esx/esx_vi_types.generated.typetostring \ + esx/esx_vi_types.generated.typefromstring + +ESX_DRIVER_EXTRA_DIST = \ + esx/README \ + esx/esx_vi_generator.input \ + esx/esx_vi_generator.py \ + $(ESX_DRIVER_GENERATED) + NETWORK_DRIVER_SOURCES = \ network/bridge_driver.h network/bridge_driver.c @@ -594,7 +610,10 @@ libvirt_driver_one_la_SOURCES = $(ONE_DRIVER_SOURCES) endif +BUILT_SOURCES += $(ESX_DRIVER_GENERATED) +$(ESX_DRIVER_GENERATED): $(srcdir)/esx/esx_vi_generator.input $(srcdir)/esx/esx_vi_generator.py + -srcdir=$(srcdir) $(srcdir)/esx/esx_vi_generator.py if WITH_ESX if WITH_DRIVER_MODULES @@ -610,6 +629,7 @@ if WITH_DRIVER_MODULES libvirt_driver_esx_la_LDFLAGS += -module -avoid-version endif libvirt_driver_esx_la_SOURCES = $(ESX_DRIVER_SOURCES) +libvirt_driver_esx_la_DEPENDENCIES = $(ESX_DRIVER_GENERATED) endif if WITH_NETWORK @@ -784,6 +804,7 @@ EXTRA_DIST += \ $(VBOX_DRIVER_SOURCES) \ $(XENAPI_DRIVER_SOURCES) \ $(ESX_DRIVER_SOURCES) \ + $(ESX_DRIVER_EXTRA_DIST) \ $(NETWORK_DRIVER_SOURCES) \ $(INTERFACE_DRIVER_SOURCES) \ $(STORAGE_DRIVER_SOURCES) \ @@ -867,7 +888,7 @@ EXTRA_DIST += \ libvirt_macvtap.syms \ libvirt_daemon.syms -BUILT_SOURCES = libvirt.syms +BUILT_SOURCES += libvirt.syms libvirt.syms: libvirt_public.syms $(USED_SYM_FILES) rm -f $@-tmp $@ diff --git a/src/esx/.gitignore b/src/esx/.gitignore new file mode 100644 index 0000000..29e1d48 --- /dev/null +++ b/src/esx/.gitignore @@ -0,0 +1 @@ +*.generated.* diff --git a/src/esx/esx_driver.c b/src/esx/esx_driver.c index bbe8a51..663c560 100644 --- a/src/esx/esx_driver.c +++ b/src/esx/esx_driver.c @@ -1924,8 +1924,14 @@ esxDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info) perfEntityMetric = perfEntityMetric->_next) { VIR_DEBUG0("perfEntityMetric ..."); - for (perfMetricIntSeries = perfEntityMetric->value; - perfMetricIntSeries != NULL; + perfMetricIntSeries = + esxVI_PerfMetricIntSeries_DynamicCast(perfEntityMetric->value); + + if (perfMetricIntSeries == NULL) { + VIR_ERROR0("QueryPerf returned object with unexpected type"); + } + + for (; perfMetricIntSeries != NULL; perfMetricIntSeries = perfMetricIntSeries->_next) { VIR_DEBUG0("perfMetricIntSeries ..."); diff --git a/src/esx/esx_vi.c b/src/esx/esx_vi.c index 326add7..c1fd4b4 100644 --- a/src/esx/esx_vi.c +++ b/src/esx/esx_vi.c @@ -3,7 +3,7 @@ * esx_vi.c: client for the VMware VI API 2.5 to manage ESX hosts * * Copyright (C) 2010 Red Hat, Inc. - * Copyright (C) 2009 Matthias Bolte <matthias.bolte@googlemail.com> + * Copyright (C) 2009-2010 Matthias Bolte <matthias.bolte@googlemail.com> * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -480,12 +480,12 @@ esxVI_Context_Connect(esxVI_Context *ctx, const char *url, dynamicProperty = dynamicProperty->_next) { if (STREQ(dynamicProperty->name, "vmFolder")) { if (esxVI_ManagedObjectReference_CastFromAnyType - (dynamicProperty->val, &ctx->vmFolder, "Folder")) { + (dynamicProperty->val, &ctx->vmFolder)) { goto failure; } } else if (STREQ(dynamicProperty->name, "hostFolder")) { if (esxVI_ManagedObjectReference_CastFromAnyType - (dynamicProperty->val, &ctx->hostFolder, "Folder")) { + (dynamicProperty->val, &ctx->hostFolder)) { goto failure; } } else { @@ -725,6 +725,21 @@ esxVI_Context_Execute(esxVI_Context *ctx, const char *methodName, "Call to '%s' returned an empty result, " "expecting a non-empty result", methodName); goto failure; + } else if ((*response)->node->next != NULL) { + ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, + "Call to '%s' returned a list, expecting " + "exactly one item", methodName); + goto failure; + } + + break; + + case esxVI_Occurrence_RequiredList: + if ((*response)->node == NULL) { + ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, + "Call to '%s' returned an empty result, " + "expecting a non-empty result", methodName); + goto failure; } break; @@ -740,7 +755,7 @@ esxVI_Context_Execute(esxVI_Context *ctx, const char *methodName, break; - case esxVI_Occurrence_List: + case esxVI_Occurrence_OptionalList: /* Any amount of items is valid */ break; @@ -821,10 +836,11 @@ esxVI_Enumeration_CastFromAnyType(const esxVI_Enumeration *enumeration, *value = 0; /* undefined */ - if (STRNEQ(anyType->other, enumeration->type)) { + if (anyType->type != enumeration->type) { ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, - "Expecting type '%s' but found '%s'", enumeration->type, - anyType->other); + "Expecting type '%s' but found '%s'", + esxVI_Type_ToString(enumeration->type), + esxVI_Type_ToString(anyType->type)); return -1; } @@ -837,7 +853,7 @@ esxVI_Enumeration_CastFromAnyType(const esxVI_Enumeration *enumeration, ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, "Unknown value '%s' for %s", anyType->value, - enumeration->type); + esxVI_Type_ToString(enumeration->type)); return -1; } @@ -870,7 +886,8 @@ esxVI_Enumeration_Serialize(const esxVI_Enumeration *enumeration, return -1; } - ESV_VI__XML_TAG__OPEN(output, element, enumeration->type); + ESV_VI__XML_TAG__OPEN(output, element, + esxVI_Type_ToString(enumeration->type)); virBufferAdd(output, name, -1); @@ -906,7 +923,7 @@ esxVI_Enumeration_Deserialize(const esxVI_Enumeration *enumeration, } ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, "Unknown value '%s' for %s", - name, enumeration->type); + name, esxVI_Type_ToString(enumeration->type)); cleanup: VIR_FREE(name); @@ -1009,7 +1026,7 @@ esxVI_List_CastFromAnyType(esxVI_AnyType *anyType, esxVI_List **list, return -1; } - for (childNode = anyType->_node->children; childNode != NULL; + for (childNode = anyType->node->children; childNode != NULL; childNode = childNode->next) { if (childNode->type != XML_ELEMENT_NODE) { ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, @@ -1151,7 +1168,7 @@ esxVI_BuildFullTraversalSpecItem(esxVI_SelectionSpec **fullTraversalSpecList, } if (esxVI_TraversalSpec_Alloc(&traversalSpec) < 0 || - esxVI_String_DeepCopyValue(&traversalSpec->_base->name, name) < 0 || + esxVI_String_DeepCopyValue(&traversalSpec->name, name) < 0 || esxVI_String_DeepCopyValue(&traversalSpec->type, type) < 0 || esxVI_String_DeepCopyValue(&traversalSpec->path, path) < 0) { goto failure; @@ -1177,7 +1194,8 @@ esxVI_BuildFullTraversalSpecItem(esxVI_SelectionSpec **fullTraversalSpecList, } if (esxVI_SelectionSpec_AppendToList(fullTraversalSpecList, - traversalSpec->_base) < 0) { + esxVI_SelectionSpec_DynamicCast + (traversalSpec)) < 0) { goto failure; } @@ -1721,8 +1739,7 @@ esxVI_LookupResourcePoolByHostSystem dynamicProperty = dynamicProperty->_next) { if (STREQ(dynamicProperty->name, "parent")) { if (esxVI_ManagedObjectReference_CastFromAnyType - (dynamicProperty->val, &managedObjectReference, - "ComputeResource") < 0) { + (dynamicProperty->val, &managedObjectReference) < 0) { goto failure; } @@ -1756,7 +1773,7 @@ esxVI_LookupResourcePoolByHostSystem dynamicProperty = dynamicProperty->_next) { if (STREQ(dynamicProperty->name, "resourcePool")) { if (esxVI_ManagedObjectReference_CastFromAnyType - (dynamicProperty->val, resourcePool, "ResourcePool") < 0) { + (dynamicProperty->val, resourcePool) < 0) { goto failure; } @@ -2231,7 +2248,7 @@ esxVI_LookupPendingTaskInfoListByVirtualMachine dynamicProperty = dynamicProperty->_next) { if (STREQ(dynamicProperty->name, "recentTask")) { if (esxVI_ManagedObjectReference_CastListFromAnyType - (dynamicProperty->val, &recentTaskList, "Task") < 0) { + (dynamicProperty->val, &recentTaskList) < 0) { goto failure; } diff --git a/src/esx/esx_vi.h b/src/esx/esx_vi.h index 1349a1b..555dad5 100644 --- a/src/esx/esx_vi.h +++ b/src/esx/esx_vi.h @@ -2,7 +2,7 @@ /* * esx_vi.h: client for the VMware VI API 2.5 to manage ESX hosts * - * Copyright (C) 2009 Matthias Bolte <matthias.bolte@googlemail.com> + * Copyright (C) 2009-2010 Matthias Bolte <matthias.bolte@googlemail.com> * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -61,8 +61,9 @@ enum _esxVI_ProductVersion { enum _esxVI_Occurrence { esxVI_Occurrence_Undefined = 0, esxVI_Occurrence_RequiredItem, + esxVI_Occurrence_RequiredList, esxVI_Occurrence_OptionalItem, - esxVI_Occurrence_List, + esxVI_Occurrence_OptionalList, esxVI_Occurrence_None }; @@ -132,7 +133,7 @@ struct _esxVI_EnumerationValue { }; struct _esxVI_Enumeration { - const char *type; + esxVI_Type type; esxVI_EnumerationValue values[10]; }; diff --git a/src/esx/esx_vi_generator.input b/src/esx/esx_vi_generator.input new file mode 100644 index 0000000..06dddbf --- /dev/null +++ b/src/esx/esx_vi_generator.input @@ -0,0 +1,426 @@ +# +# Definitions of vSphere API 2.5 enumeration and objects types used as input +# for the esx_vi_generator.py script. +# +# This format is line-based, so end-of-line is important. +# +# +# Enumeration definition: +# +# enum <name> +# <value> +# ... +# end +# +# +# Object definition: +# +# object <name> [extends <name>] +# <type> <name> <occurrence> +# ... +# end +# +# Possible values for the <occurrence> field are: +# +# - r for a required item +# - rl for a required list +# - o for an optional item +# - ol for an optional list +# - i for an ignored item or list +# +# Object member sequence has to match the WSDL sequence +# + + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# Enumerations +# + +enum ManagedEntityStatus + gray + green + yellow + red +end + + +enum ObjectUpdateKind + modify + enter + leave +end + + +enum PerfStatsType + absolute + delta + rate +end + + +enum PerfSummaryType + average + maximum + minimum + latest + summation + none +end + + +enum PropertyChangeOp + add + remove + assign + indirectRemove +end + + +enum SharesLevel + low + normal + high + custom +end + + +enum TaskInfoState + queued + running + success + error +end + + +enum VirtualMachineMovePriority + lowPriority + highPriority + defaultPriority +end + + +enum VirtualMachinePowerState + poweredOff + poweredOn + suspended +end + + +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# Objects +# + +object AboutInfo + String name r + String fullName r + String vendor r + String version r + String build r + String localeVersion o + String localeBuild o + String osType r + String productLineId r + String apiType r + String apiVersion r +end + + +object ChoiceOption extends OptionType + ElementDescription choiceInfo rl + Int defaultIndex o +end + + +object Description + String label r + String summary r +end + + +object DynamicProperty + String name r + AnyType val r +end + + +object ElementDescription extends Description + String key r +end + + +object Event + Int key r + Int chainId r + DateTime createdTime r + String userName r + DatacenterEventArgument datacenter i + ComputeResourceEventArgument computeResource i + HostEventArgument host i + VmEventArgument vm i + String fullFormattedMessage o +end + + +object HostCpuIdInfo + Int level r + String vendor o + String eax o + String ebx o + String ecx o + String edx o +end + + +object ObjectContent + ManagedObjectReference obj r + DynamicProperty propSet ol + MissingProperty missingSet i +end + + +object ObjectSpec + ManagedObjectReference obj r + Boolean skip o + SelectionSpec selectSet ol +end + + +object ObjectUpdate + ObjectUpdateKind kind r + ManagedObjectReference obj r + PropertyChange changeSet ol + MissingProperty missingSet i +end + + +object OptionType + Boolean valueIsReadonly o +end + + +object PerfCounterInfo + Int key r + ElementDescription nameInfo r + ElementDescription groupInfo r + ElementDescription unitInfo r + PerfSummaryType rollupType r + PerfStatsType statsType r + Int level o + Int associatedCounterId ol +end + + +object PerfEntityMetric extends PerfEntityMetricBase + PerfSampleInfo sampleInfo ol + PerfMetricSeries value ol +end + + +object PerfEntityMetricBase + ManagedObjectReference entity r +end + + +object PerfMetricId + Int counterId r + String instance r +end + + +object PerfMetricIntSeries extends PerfMetricSeries + Long value ol +end + + +object PerfMetricSeries + PerfMetricId id r +end + + +object PerfQuerySpec + ManagedObjectReference entity r + DateTime startTime o + DateTime endTime o + Int maxSample o + PerfMetricId metricId ol + Int intervalId o + String format o +end + + +object PerfSampleInfo + DateTime timestamp r + Int interval r +end + + +object PropertyChange + String name r + PropertyChangeOp op r + AnyType val o +end + + +object PropertyFilterSpec + PropertySpec propSet rl + ObjectSpec objectSet rl +end + + +object PropertyFilterUpdate + ManagedObjectReference filter r + ObjectUpdate objectSet ol + MissingObject missingSet i +end + + +object PropertySpec + String type r + Boolean all o + String pathSet ol +end + + +object ResourceAllocationInfo + Long reservation o + Boolean expandableReservation o + Long limit o + SharesInfo shares o + Long overheadLimit o +end + + +object ResourcePoolResourceUsage + Long reservationUsed r + Long reservationUsedForVm r + Long unreservedForPool r + Long unreservedForVm r + Long overallUsage r + Long maxUsage r +end + + +object SelectionSpec + String name o +end + + +object ServiceContent + ManagedObjectReference rootFolder r + ManagedObjectReference propertyCollector r + ManagedObjectReference viewManager o + AboutInfo about r + ManagedObjectReference setting o + ManagedObjectReference userDirectory o + ManagedObjectReference sessionManager o + ManagedObjectReference authorizationManager o + ManagedObjectReference perfManager o + ManagedObjectReference scheduledTaskManager o + ManagedObjectReference alarmManager o + ManagedObjectReference eventManager o + ManagedObjectReference taskManager o + ManagedObjectReference extensionManager o + ManagedObjectReference customizationSpecManager o + ManagedObjectReference customFieldsManager o + ManagedObjectReference accountManager o + ManagedObjectReference diagnosticManager o + ManagedObjectReference licenseManager o + ManagedObjectReference searchIndex o + ManagedObjectReference fileManager o + ManagedObjectReference virtualDiskManager o + ManagedObjectReference virtualizationManager o +end + + +object SharesInfo + Int shares r + SharesLevel level r +end + + +object TaskInfo + String key r + ManagedObjectReference task r + String name o + String descriptionId r + ManagedObjectReference entity o + String entityName o + ManagedObjectReference locked ol + TaskInfoState state r + Boolean cancelled r + Boolean cancelable r + LocalizedMethodFault error i + AnyType result o + Int progress o + TaskReason reason i + DateTime queueTime r + DateTime startTime o + DateTime completeTime o + Int eventChainId r +end + + +object TraversalSpec extends SelectionSpec + String type r + String path r + Boolean skip o + SelectionSpec selectSet ol +end + + +object UpdateSet + String version r + PropertyFilterUpdate filterSet ol +end + + +object UserSession + String key r + String userName r + String fullName r + DateTime loginTime r + DateTime lastActiveTime r + String locale r + String messageLocale r +end + + +object VirtualMachineConfigSpec + String changeVersion o + String name o + String version o + String uuid o + Long npivNodeWorldWideName ol + Long npivPortWorldWideName ol + String npivWorldWideNameType o + String npivWorldWideNameOp o + String locationId o + String guestId o + String alternateGuestName o + String annotation o + VirtualMachineFileInfo files i + ToolsConfigInfo tools i + VirtualMachineFlagInfo flags i + VirtualMachineConsolePreferences consolePreferences i + VirtualMachineDefaultPowerOpInfo powerOpInfo i + Int numCPUs o + Long memoryMB o + VirtualDeviceConfigSpec deviceChange i + ResourceAllocationInfo cpuAllocation o + ResourceAllocationInfo memoryAllocation o + VirtualMachineAffinityInfo cpuAffinity i + VirtualMachineAffinityInfo memoryAffinity i + VirtualMachineNetworkShaperInfo networkShaper i + VirtualMachineCpuIdInfoSpec cpuFeatureMask i + OptionValue extraConfig i + String swapPlacement o + VirtualMachineBootOptions bootOptions i +end + + +object VirtualMachineQuestionInfo + String id r + String text r + ChoiceOption choice r + VirtualMachineMessage message i +end diff --git a/src/esx/esx_vi_generator.py b/src/esx/esx_vi_generator.py new file mode 100755 index 0000000..5ca6138 --- /dev/null +++ b/src/esx/esx_vi_generator.py @@ -0,0 +1,1025 @@ +#!/usr/bin/python + +# +# esx_vi_generator.py: generates most of the SOAP type mapping code +# +# Copyright (C) 2010 Matthias Bolte <matthias.bolte@googlemail.com> +# +# 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 +# + +import sys +import os +import os.path + + + + + + +class Property: + OCCURRENCE__REQUIRED_ITEM = "r" + OCCURRENCE__REQUIRED_LIST = "rl" + OCCURRENCE__OPTIONAL_ITEM = "o" + OCCURRENCE__OPTIONAL_LIST = "ol" + OCCURRENCE__IGNORED = "i" + + valid_occurrences = [OCCURRENCE__REQUIRED_ITEM, + OCCURRENCE__REQUIRED_LIST, + OCCURRENCE__OPTIONAL_ITEM, + OCCURRENCE__OPTIONAL_LIST, + OCCURRENCE__IGNORED] + + def __init__(self, type, name, occurrence): + self.type = type + self.name = name + self.occurrence = occurrence + + def is_enum(self): + global predefined_enums + global enums_by_name + + return self.type in predefined_enums or self.type in enums_by_name + + def generate_struct_member(self): + if self.occurrence == Property.OCCURRENCE__IGNORED: + return " /* FIXME: %s is currently ignored */\n" % self.name + else: + string = " %s%s; " % (self.get_type_string(), self.name) + + while len(string) < 59: + string += " " + + return string + "/* %s */\n" % self.get_occurrence_string() + + def generate_free_code(self): + if self.type == "String" and \ + self.occurrence not in [Property.OCCURRENCE__REQUIRED_LIST, + Property.OCCURRENCE__OPTIONAL_LIST, + Property.OCCURRENCE__IGNORED]: + return " VIR_FREE(item->%s);\n" % self.name + elif self.is_enum(): + return "" + else: + if self.occurrence == Property.OCCURRENCE__IGNORED: + return " /* FIXME: %s is currently ignored */\n" % self.name + else: + return " esxVI_%s_Free(&item->%s);\n" % (self.type, self.name) + + def generate_validate_code(self): + if self.occurrence in [Property.OCCURRENCE__REQUIRED_ITEM, + Property.OCCURRENCE__REQUIRED_LIST]: + return " ESX_VI__TEMPLATE__PROPERTY__REQUIRE(%s)\n" % self.name + elif self.occurrence == Property.OCCURRENCE__IGNORED: + return " /* FIXME: %s is currently ignored */\n" % self.name + else: + return "" + + def generate_deep_copy_code(self): + if self.occurrence == Property.OCCURRENCE__IGNORED: + return " /* FIXME: %s is currently ignored */\n" % self.name + elif self.occurrence in [Property.OCCURRENCE__REQUIRED_LIST, + Property.OCCURRENCE__OPTIONAL_LIST]: + return " ESX_VI__TEMPLATE__PROPERTY__DEEP_COPY_LIST(%s, %s)\n" % (self.type, self.name) + elif self.type == "String": + return " ESX_VI__TEMPLATE__PROPERTY__DEEP_COPY_VALUE(String, %s)\n" % self.name + else: + return " ESX_VI__TEMPLATE__PROPERTY__DEEP_COPY(%s, %s)\n" % (self.type, self.name) + + def generate_serialize_code(self): + if self.occurrence == Property.OCCURRENCE__IGNORED: + return " /* FIXME: %s is currently ignored */\n" % self.name + elif self.occurrence in [Property.OCCURRENCE__REQUIRED_LIST, + Property.OCCURRENCE__OPTIONAL_LIST]: + return " ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_LIST(%s, %s)\n" % (self.type, self.name) + elif self.type == "String": + return " ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_VALUE(String, %s)\n" % self.name + else: + return " ESX_VI__TEMPLATE__PROPERTY__SERIALIZE(%s, %s)\n" % (self.type, self.name) + + def generate_deserialize_code(self): + if self.occurrence == Property.OCCURRENCE__IGNORED: + return " ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_IGNORE(%s) /* FIXME */\n" % self.name + elif self.occurrence in [Property.OCCURRENCE__REQUIRED_LIST, + Property.OCCURRENCE__OPTIONAL_LIST]: + return " ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_LIST(%s, %s)\n" % (self.type, self.name) + elif self.type == "String": + return " ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, %s)\n" % self.name + else: + return " ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(%s, %s)\n" % (self.type, self.name) + + def get_type_string(self): + if self.type == "String" and \ + self.occurrence not in [Property.OCCURRENCE__REQUIRED_LIST, + Property.OCCURRENCE__OPTIONAL_LIST]: + return "char *" + elif self.is_enum(): + return "esxVI_%s " % self.type + else: + return "esxVI_%s *" % self.type + + def get_occurrence_string(self): + if self.occurrence == Property.OCCURRENCE__REQUIRED_ITEM: + return "required" + elif self.occurrence == Property.OCCURRENCE__REQUIRED_LIST: + return "required, list" + elif self.occurrence == Property.OCCURRENCE__OPTIONAL_ITEM: + return "optional" + elif self.occurrence == Property.OCCURRENCE__OPTIONAL_LIST: + return "optional, list" + + raise ValueError("unknown cardinality value '%s'" % self.cardinality) + + + + + + + + +class Object: + FEATURE__DYNAMIC_CAST = (1 << 1) + FEATURE__LIST = (1 << 2) + FEATURE__DEEP_COPY = (1 << 3) + FEATURE__ANY_TYPE = (1 << 4) + FEATURE__SERIALIZE = (1 << 5) + FEATURE__DESERIALIZE = (1 << 6) + + def __init__(self, name, extends, properties, features = 0, extended_by = None): + self.name = name + self.extends = extends + self.features = features | Object.FEATURE__SERIALIZE | Object.FEATURE__DESERIALIZE + self.properties = properties + self.extended_by = extended_by + + self.properties_by_name = {} + + for property in self.properties: + self.properties_by_name[property.name] = property + + def generate_struct_members(self, add_banner = False, struct_gap = False): + global objects_by_name + members = "" + + if self.extends is None: + struct_gap = True + string = " esxVI_Type _type; " + + while len(string) < 59: + string += " " + + members += string + "/* required */\n" + + if struct_gap and self.extends is None: + members += "\n" + + if self.extends is not None: + members += objects_by_name[self.extends].generate_struct_members(add_banner = True, struct_gap = False) + "\n" + + if self.extends is not None or add_banner: + members += " /* %s */\n" % self.name + + for property in self.properties: + members += property.generate_struct_member() + + if len(self.properties) < 1: + members += " /* no properties */\n" + + return members + + def generate_free_code(self, add_banner = False): + global objects_by_name + source = "" + + if self.extends is not None: + source += objects_by_name[self.extends].generate_free_code(add_banner = True) + "\n" + + if self.extends is not None or add_banner: + source += " /* %s */\n" % self.name + + if len(self.properties) < 1: + source += " /* no properties */\n" + else: + string = "" + + for property in self.properties: + string += property.generate_free_code() + + if len(string) < 1: + source += " /* no properties to be freed */\n" + else: + source += string + + return source + + def generate_validate_code(self, add_banner = False): + global objects_by_name + source = "" + + if self.extends is not None: + source += objects_by_name[self.extends].generate_validate_code(add_banner = True) + "\n" + + if self.extends is not None or add_banner: + source += " /* %s */\n" % self.name + + if len(self.properties) < 1: + source += " /* no properties */\n" + else: + string = "" + + for property in self.properties: + string += property.generate_validate_code() + + if len(string) < 1: + source += " /* no required properties */\n" + else: + source += string + + return source + + def generate_dynamic_cast_code(self): + global objects_by_name + source = "" + + if self.extended_by is not None: + source += " /* %s */\n" % self.name + + for extended_by in self.extended_by: + source += " ESX_VI__TEMPLATE__DYNAMIC_CAST__ACCEPT(%s)\n" % extended_by + + for extended_by in self.extended_by: + source += objects_by_name[extended_by].generate_dynamic_cast_code() + + return source + + def generate_deep_copy_code(self, add_banner = False): + global objects_by_name + source = "" + + if self.extends is not None: + source += objects_by_name[self.extends].generate_deep_copy_code(add_banner = True) + "\n" + + if self.extends is not None or add_banner: + source += " /* %s */\n" % self.name + + if len(self.properties) < 1: + source += " /* no properties */\n" + else: + string = "" + + for property in self.properties: + string += property.generate_deep_copy_code() + + if len(string) < 1: + source += " /* no properties to be deep copied */\n" + else: + source += string + + return source + + def generate_serialize_code(self, add_banner = False): + global objects_by_name + source = "" + + if self.extends is not None: + source += objects_by_name[self.extends].generate_serialize_code(add_banner = True) + "\n" + + if self.extends is not None or add_banner: + source += " /* %s */\n" % self.name + + if len(self.properties) < 1: + source += " /* no properties */\n" + else: + for property in self.properties: + source += property.generate_serialize_code() + + return source + + def generate_deserialize_code(self, add_banner = False): + global objects_by_name + source = "" + + if self.extends is not None: + source += objects_by_name[self.extends].generate_deserialize_code(add_banner = True) + "\n" + + if self.extends is not None or add_banner: + source += " /* %s */\n" % self.name + + if len(self.properties) < 1: + source += " /* no properties */\n" + else: + for property in self.properties: + source += property.generate_deserialize_code() + + return source + + def generate_typedef(self): + return "typedef struct _esxVI_%s esxVI_%s;\n" % (self.name, self.name) + + def generate_typeenum(self): + return " esxVI_Type_%s,\n" % self.name + + def generate_typetostring(self): + string = " case esxVI_Type_%s:\n" % self.name + string += " return \"%s\";\n\n" % self.name + + return string + + def generate_typefromstring(self): + string = " else if (STREQ(type, \"%s\")) {\n" % self.name + string += " return esxVI_Type_%s;\n" % self.name + string += " }\n" + + return string + + def generate_header(self): + header = "/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n" + header += " * VI Type: %s\n" % self.name + + if self.extends is not None: + header += " * extends %s\n" % self.extends + + first = True + + if self.extended_by is not None: + for extended_by in self.extended_by: + if first: + header += " * extended by %s\n" % extended_by + first = False + else: + header += " * %s\n" % extended_by + + header += " */\n\n" + + # struct + header += "struct _esxVI_%s {\n" % self.name + + if self.features & Object.FEATURE__LIST: + string = " esxVI_%s *_next; " % self.name + else: + string = " esxVI_%s *_unused; " % self.name + + while len(string) < 59: + string += " " + + header += string + "/* optional */\n" + + header += self.generate_struct_members(struct_gap = True) + + header += "};\n\n" + + # functions + header += "int esxVI_%s_Alloc(esxVI_%s **item);\n" % (self.name, self.name) + header += "void esxVI_%s_Free(esxVI_%s **item);\n" % (self.name, self.name) + header += "int esxVI_%s_Validate(esxVI_%s *item);\n" % (self.name, self.name) + + if self.features & Object.FEATURE__DYNAMIC_CAST: + if self.extended_by is not None or self.extends is not None: + header += "esxVI_%s *esxVI_%s_DynamicCast(void *item);\n" % (self.name, self.name) + else: + report_error("cannot add dynamic cast support for an untyped object") + + if self.features & Object.FEATURE__LIST: + header += "int esxVI_%s_AppendToList(esxVI_%s **list, esxVI_%s *item);\n" % (self.name, self.name, self.name) + + if self.features & Object.FEATURE__DEEP_COPY: + header += "int esxVI_%s_DeepCopy(esxVI_%s **dst, esxVI_%s *src);\n" % (self.name, self.name, self.name) + + if self.features & Object.FEATURE__LIST: + header += "int esxVI_%s_DeepCopyList(esxVI_%s **dstList, esxVI_%s *srcList);\n" % (self.name, self.name, self.name) + + if self.features & Object.FEATURE__ANY_TYPE: + header += "int esxVI_%s_CastFromAnyType(esxVI_AnyType *anyType, esxVI_%s **item);\n" % (self.name, self.name) + + if self.features & Object.FEATURE__LIST: + header += "int esxVI_%s_CastListFromAnyType(esxVI_AnyType *anyType, esxVI_%s **list);\n" % (self.name, self.name) + + if self.features & Object.FEATURE__SERIALIZE: + header += "int esxVI_%s_Serialize(esxVI_%s *item, const char *element, virBufferPtr output);\n" % (self.name, self.name) + + if self.features & Object.FEATURE__LIST: + header += "int esxVI_%s_SerializeList(esxVI_%s *list, const char *element, virBufferPtr output);\n" % (self.name, self.name) + + if self.features & Object.FEATURE__DESERIALIZE: + header += "int esxVI_%s_Deserialize(xmlNodePtr node, esxVI_%s **item);\n" % (self.name, self.name) + + if self.features & Object.FEATURE__LIST: + header += "int esxVI_%s_DeserializeList(xmlNodePtr node, esxVI_%s **list);\n" % (self.name, self.name) + + header += "\n\n\n" + + return header + + def generate_source(self): + source = "/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n" + source += " * VI Type: %s\n" % self.name + + if self.extends is not None: + source += " * extends %s\n" % self.extends + + first = True + + if self.extended_by is not None: + for extended_by in self.extended_by: + if first: + source += " * extended by %s\n" % extended_by + first = False + else: + source += " * %s\n" % extended_by + + source += " */\n\n" + + # functions + source += "/* esxVI_%s_Alloc */\n" % self.name + source += "ESX_VI__TEMPLATE__ALLOC(%s)\n\n" % self.name + + # free + if self.extended_by is None: + source += "/* esxVI_%s_Free */\n" % self.name + source += "ESX_VI__TEMPLATE__FREE(%s,\n" % self.name + source += "{\n" + + if self.features & Object.FEATURE__LIST: + source += " esxVI_%s_Free(&item->_next);\n\n" % self.name + + source += self.generate_free_code() + + source += "})\n\n" + else: + source += "/* esxVI_%s_Free */\n" % self.name + source += "ESX_VI__TEMPLATE__DYNAMIC_FREE(%s,\n" % self.name + source += "{\n" + + for extended_by in self.extended_by: + source += " ESX_VI__TEMPLATE__DISPATCH__FREE(%s)\n" % extended_by + + source += "},\n" + source += "{\n" + + if self.features & Object.FEATURE__LIST: + source += " esxVI_%s_Free(&item->_next);\n\n" % self.name + + source += self.generate_free_code() + + source += "})\n\n" + + # validate + source += "/* esxVI_%s_Validate */\n" % self.name + source += "ESX_VI__TEMPLATE__VALIDATE(%s,\n" % self.name + source += "{\n" + + source += self.generate_validate_code() + + source += "})\n\n" + + # dynamic cast + if self.features & Object.FEATURE__DYNAMIC_CAST: + if self.extended_by is not None or self.extends is not None: + source += "/* esxVI_%s_DynamicCast */\n" % self.name + source += "ESX_VI__TEMPLATE__DYNAMIC_CAST(%s,\n" % self.name + source += "{\n" + + source += self.generate_dynamic_cast_code() + + source += "})\n\n" + else: + report_error("cannot add dynamic cast support for an untyped object") + + # append to list + if self.features & Object.FEATURE__LIST: + source += "/* esxVI_%s_AppendToList */\n" % self.name + source += "ESX_VI__TEMPLATE__LIST__APPEND(%s)\n\n" % self.name + + # deep copy + if self.extended_by is None: + if self.features & Object.FEATURE__DEEP_COPY: + source += "/* esxVI_%s_DeepCopy */\n" % self.name + source += "ESX_VI__TEMPLATE__DEEP_COPY(%s,\n" % self.name + source += "{\n" + + source += self.generate_deep_copy_code() + + source += "})\n\n" + + if self.features & Object.FEATURE__LIST: + source += "/* esxVI_%s_DeepCopyList */\n" % self.name + source += "ESX_VI__TEMPLATE__LIST__DEEP_COPY(%s)\n\n" % self.name + else: + if self.features & Object.FEATURE__DEEP_COPY: + source += "/* esxVI_%s_DeepCopy */\n" % self.name + source += "ESX_VI__TEMPLATE__DYNAMIC_DEEP_COPY(%s)\n" % self.name + source += "{\n" + + for extended_by in self.extended_by: + source += " ESX_VI__TEMPLATE__DISPATCH__DEEP_COPY(%s)\n" % extended_by + + source += "},\n" + source += "{\n" + + source += self.generate_deep_copy_code() + + source += "})\n\n" + + if self.features & Object.FEATURE__LIST: + source += "/* esxVI_%s_DeepCopyList */\n" % self.name + source += "ESX_VI__TEMPLATE__LIST__DEEP_COPY(%s)\n\n" % self.name + + # cast from any type + if self.features & Object.FEATURE__ANY_TYPE: + source += "/* esxVI_%s_CastFromAnyType */\n" % self.name + source += "ESX_VI__TEMPLATE__CAST_FROM_ANY_TYPE(%s)\n" % self.name + + if self.features & Object.FEATURE__LIST: + source += "/* esxVI_%s_CastListFromAnyType */\n" % self.name + source += "ESX_VI__TEMPLATE__LIST__CAST_FROM_ANY_TYPE(%s)\n\n" % self.name + + # serialize + if self.extended_by is None: + if self.features & Object.FEATURE__SERIALIZE: + source += "/* esxVI_%s_Serialize */\n" % self.name + source += "ESX_VI__TEMPLATE__SERIALIZE(%s,\n" % self.name + source += "{\n" + + source += self.generate_serialize_code() + + source += "})\n\n" + + if self.features & Object.FEATURE__LIST: + source += "/* esxVI_%s_SerializeList */\n" % self.name + source += "ESX_VI__TEMPLATE__LIST__SERIALIZE(%s)\n\n" % self.name + else: + if self.features & Object.FEATURE__SERIALIZE: + source += "/* esxVI_%s_Serialize */\n" % self.name + source += "ESX_VI__TEMPLATE__DYNAMIC_SERIALIZE(%s,\n" % self.name + source += "{\n" + + for extended_by in self.extended_by: + source += " ESX_VI__TEMPLATE__DISPATCH__SERIALIZE(%s)\n" % extended_by + + source += "},\n" + source += "{\n" + + source += self.generate_serialize_code() + + source += "})\n\n" + + if self.features & Object.FEATURE__LIST: + source += "/* esxVI_%s_SerializeList */\n" % self.name + source += "ESX_VI__TEMPLATE__LIST__SERIALIZE(%s)\n\n" % self.name + + # deserilaize + if self.features & Object.FEATURE__DESERIALIZE: + source += "/* esxVI_%s_Deserialize */\n" % self.name + source += "ESX_VI__TEMPLATE__DESERIALIZE(%s,\n" % self.name + source += "{\n" + + source += self.generate_deserialize_code() + + source += "})\n\n" + + if self.features & Object.FEATURE__LIST: + source += "/* esxVI_%s_DeserializeList */\n" % self.name + source += "ESX_VI__TEMPLATE__LIST__DESERIALIZE(%s)\n\n" % self.name + + source += "\n\n" + + return source + + + + + + + + +class Enum: + FEATURE__ANY_TYPE = (1 << 1) + FEATURE__SERIALIZE = (1 << 2) + FEATURE__DESERIALIZE = (1 << 3) + + + def __init__(self, name, values, features = 0): + self.name = name + self.values = values + self.features = features | Enum.FEATURE__SERIALIZE | Enum.FEATURE__DESERIALIZE + + def generate_typedef(self): + return "typedef enum _esxVI_%s esxVI_%s;\n" % (self.name, self.name) + + def generate_typeenum(self): + return " esxVI_Type_%s,\n" % self.name + + def generate_typetostring(self): + string = " case esxVI_Type_%s:\n" % self.name + string += " return \"%s\";\n\n" % self.name + + return string + + def generate_typefromstring(self): + string = " else if (STREQ(type, \"%s\")) {\n" % self.name + string += " return esxVI_Type_%s;\n" % self.name + string += " }\n" + + return string + + def generate_header(self): + header = "/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n" + header += " * VI Enum: %s\n" % self.name + header += " */\n\n" + + # enum + header += "enum _esxVI_%s {\n" % self.name + header += " esxVI_%s_Undefined = 0,\n" % self.name + + for value in self.values: + header += " esxVI_%s_%s,\n" % (self.name, capitalize_first(value)) + + header += "};\n\n" + + # functions + if self.features & Enum.FEATURE__ANY_TYPE: + header += "int esxVI_%s_CastFromAnyType(esxVI_AnyType *anyType, esxVI_%s *item);\n" % (self.name, self.name) + + if self.features & Enum.FEATURE__SERIALIZE: + header += "int esxVI_%s_Serialize(esxVI_%s item, const char *element, virBufferPtr output);\n" % (self.name, self.name) + + if self.features & Enum.FEATURE__DESERIALIZE: + header += "int esxVI_%s_Deserialize(xmlNodePtr node, esxVI_%s *item);\n" % (self.name, self.name) + + header += "\n\n\n" + + return header + + def generate_source(self): + source = "/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n" + source += " * VI Enum: %s\n" % self.name + source += " */\n\n" + + source += "static const esxVI_Enumeration _esxVI_%s_Enumeration = {\n" % self.name + source += " esxVI_Type_%s, {\n" % self.name + + for value in self.values: + source += " { \"%s\", esxVI_%s_%s },\n" % (value, self.name, capitalize_first(value)) + + source += " { NULL, -1 },\n" + source += " },\n" + source += "};\n\n" + + # functions + if self.features & Enum.FEATURE__ANY_TYPE: + source += "/* esxVI_%s_CastFromAnyType */\n" % self.name + source += "ESX_VI__TEMPLATE__ENUMERATION__CAST_FROM_ANY_TYPE(%s)\n\n" % self.name + + if self.features & Enum.FEATURE__SERIALIZE: + source += "/* esxVI_%s_Serialize */\n" % self.name + source += "ESX_VI__TEMPLATE__ENUMERATION__SERIALIZE(%s)\n\n" % self.name + + if self.features & Enum.FEATURE__DESERIALIZE: + source += "/* esxVI_%s_Deserialize */\n" % self.name + source += "ESX_VI__TEMPLATE__ENUMERATION__DESERIALIZE(%s)\n\n" % self.name + + source += "\n\n" + + return source + + + + + +def report_error(message): + print "error: " + message + sys.exit(1) + + + +def usage(): + print "%s <input-filename> <output-directory>" % sys.argv[0] + sys.exit(0) + + + +def capitalize_first(string): + return string[:1].upper() + string[1:] + + + +def parse_object(block): + # expected format: object <name> [extends <name>] + header_items = block[0][1].split() + + if len(header_items) < 2: + report_error("line %d: invalid block header" % (number)) + + assert header_items[0] == "object" + + name = header_items[1] + extends = None + + if len(header_items) > 2: + if header_items[2] != "extends": + report_error("line %d: invalid block header" % (number)) + else: + extends = header_items[3] + + properties = [] + + for line in block[1:]: + # expected format: <type> <name> <occurrence> + items = line[1].split() + + if len(items) != 3: + report_error("line %d: invalid property" % line[0]) + + if items[2] not in Property.valid_occurrences: + report_error("line %d: invalid occurrence" % line[0]) + + properties.append(Property(type = items[0], name = items[1], + occurrence = items[2])) + + return Object(name = name, extends = extends, properties = properties) + + + +def parse_enum(block): + # expected format: enum <name> + header_items = block[0][1].split() + + if len(header_items) < 2: + report_error("line %d: invalid block header" % (number)) + + assert header_items[0] == "enum" + + name = header_items[1] + + values = [] + + for line in block[1:]: + # expected format: <value> + values.append(line[1]) + + return Enum(name = name, values = values) + + + +def inherit_features(obj): + if obj.extended_by is not None: + for extended_by in obj.extended_by: + objects_by_name[extended_by].features |= obj.features + + if obj.extends is not None: + objects_by_name[obj.extends].features |= obj.features + + if obj.extended_by is not None: + for extended_by in obj.extended_by: + inherit_features(objects_by_name[extended_by]) + + + +def is_known_type(type): + return type in predefined_objects or \ + type in predefined_enums or \ + type in objects_by_name or \ + type in enums_by_name + + + +def open_and_print(filename): + if filename.startswith("./"): + print " GEN " + filename[2:] + else: + print " GEN " + filename + + return open(filename, "wb") + + + + + + + + + + +predefined_enums = ["Boolean"] + +predefined_objects = ["AnyType", + "Int", + "Long", + "String", + "DateTime", + "ManagedObjectReference"] + + +additional_enum_features = { "ManagedEntityStatus" : Enum.FEATURE__ANY_TYPE, + "TaskInfoState" : Enum.FEATURE__ANY_TYPE, + "VirtualMachinePowerState" : Enum.FEATURE__ANY_TYPE } + + +additional_object_features = { "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, + "PerfCounterInfo" : Object.FEATURE__LIST, + "PerfEntityMetric" : Object.FEATURE__LIST, + "PerfQuerySpec" : Object.FEATURE__LIST, + "PerfMetricIntSeries" : Object.FEATURE__DYNAMIC_CAST, + "PropertyFilterSpec" : Object.FEATURE__LIST, + "ResourcePoolResourceUsage" : Object.FEATURE__ANY_TYPE, + "SelectionSpec" : Object.FEATURE__DYNAMIC_CAST, + "SharesInfo" : Object.FEATURE__ANY_TYPE, + "TaskInfo" : Object.FEATURE__ANY_TYPE | Object.FEATURE__LIST, + "UserSession" : Object.FEATURE__ANY_TYPE, + "VirtualMachineQuestionInfo" : Object.FEATURE__ANY_TYPE } + + +removed_object_features = { "DynamicProperty" : Object.FEATURE__SERIALIZE, + "ObjectContent" : Object.FEATURE__SERIALIZE, + "ObjectUpdate" : Object.FEATURE__SERIALIZE, + "PropertyChange" : Object.FEATURE__SERIALIZE, + "PropertyFilterUpdate" : Object.FEATURE__SERIALIZE, + "TaskInfo" : Object.FEATURE__SERIALIZE, + "UpdateSet" : Object.FEATURE__SERIALIZE, + "VirtualMachineConfigInfo" : Object.FEATURE__SERIALIZE } + + + + +if "srcdir" in os.environ: + input_filename = os.path.join(os.environ["srcdir"], "esx/esx_vi_generator.input") + output_dirname = os.path.join(os.environ["srcdir"], "esx") +else: + input_filename = os.path.join(os.getcwd(), "esx_vi_generator.input") + output_dirname = os.getcwd() + + + +typedef = open_and_print(os.path.join(output_dirname, "esx_vi_types.generated.typedef")) +typeenum = open_and_print(os.path.join(output_dirname, "esx_vi_types.generated.typeenum")) +typetostring = open_and_print(os.path.join(output_dirname, "esx_vi_types.generated.typetostring")) +typefromstring = open_and_print(os.path.join(output_dirname, "esx_vi_types.generated.typefromstring")) +header = open_and_print(os.path.join(output_dirname, "esx_vi_types.generated.h")) +source = open_and_print(os.path.join(output_dirname, "esx_vi_types.generated.c")) + + + +number = 0 +objects_by_name = {} +enums_by_name = {} +block = None + + + +for line in file(input_filename, "rb").readlines(): + number += 1 + + if "#" in line: + line = line[:line.index("#")] + + line = line.lstrip().rstrip() + + if len(line) < 1: + continue + + if line.startswith("object") or line.startswith("enum"): + if block is not None: + report_error("line %d: nested block found" % (number)) + else: + block = [] + + if block is not None: + if line == "end": + if block[0][1].startswith("object"): + obj = parse_object(block) + objects_by_name[obj.name] = obj + else: + enum = parse_enum(block) + enums_by_name[enum.name] = enum + + block = None + else: + block.append((number, line)) + + + +for enum in enums_by_name.values(): + # apply additional features + if enum.name in additional_enum_features: + enum.features |= additional_enum_features[enum.name] + + + +for obj in objects_by_name.values(): + for property in obj.properties: + if property.occurrence != Property.OCCURRENCE__IGNORED and \ + not is_known_type(property.type): + report_error("object '%s' contains unknown property type '%s'" % (obj.name, property.type)) + + if obj.extends is not None: + if not is_known_type(obj.extends): + report_error("object '%s' extends unknown object '%s'" % (obj.name, obj.extends)) + + # detect list usage + for property in obj.properties: + if (property.occurrence == Property.OCCURRENCE__REQUIRED_LIST or \ + property.occurrence == Property.OCCURRENCE__OPTIONAL_LIST) and \ + property.type not in predefined_objects: + objects_by_name[property.type].features |= Object.FEATURE__LIST + + # apply/remove additional features + if obj.name in additional_object_features: + obj.features |= additional_object_features[obj.name] + + if obj.name in removed_object_features: + obj.features &= ~removed_object_features[obj.name] + + # spread deep copy onto properties + if obj.features & Object.FEATURE__DEEP_COPY: + for property in obj.properties: + if property.occurrence != Property.OCCURRENCE__IGNORED and \ + property.type not in predefined_objects: + objects_by_name[property.type].features |= Object.FEATURE__DEEP_COPY + + # detect extended_by relation + if obj.extends is not None: + extended_obj = objects_by_name[obj.extends] + + if extended_obj.extended_by is None: + extended_obj.extended_by = [obj.name] + else: + extended_obj.extended_by.append(obj.name) + + + + + +for obj in objects_by_name.values(): + inherit_features(obj) + + + + + +typedef.write("/* Generated by esx_vi_generator.py */\n\n\n\n") +typeenum.write("/* Generated by esx_vi_generator.py */\n\n") +typetostring.write("/* Generated by esx_vi_generator.py */\n\n") +typefromstring.write("/* Generated by esx_vi_generator.py */\n\n") +header.write("/* Generated by esx_vi_generator.py */\n\n\n\n") +source.write("/* Generated by esx_vi_generator.py */\n\n\n\n") + + +typedef.write("/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n" + + " * VI Enums\n" + + " */\n\n") + + + +names = enums_by_name.keys() +names.sort() + + +for name in names: + typedef.write(enums_by_name[name].generate_typedef()) + typeenum.write(enums_by_name[name].generate_typeenum()) + typetostring.write(enums_by_name[name].generate_typetostring()) + typefromstring.write(enums_by_name[name].generate_typefromstring()) + header.write(enums_by_name[name].generate_header()) + source.write(enums_by_name[name].generate_source()) + + + +typedef.write("\n\n\n" + + "/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n" + + " * VI Types\n" + + " */\n\n") + +typeenum.write("\n") + +typetostring.write("\n") + +typefromstring.write("\n") + + + +names = objects_by_name.keys() +names.sort() + + +for name in names: + typedef.write(objects_by_name[name].generate_typedef()) + typeenum.write(objects_by_name[name].generate_typeenum()) + typetostring.write(objects_by_name[name].generate_typetostring()) + typefromstring.write(objects_by_name[name].generate_typefromstring()) + header.write(objects_by_name[name].generate_header()) + source.write(objects_by_name[name].generate_source()) diff --git a/src/esx/esx_vi_methods.c b/src/esx/esx_vi_methods.c index 07cd82a..f1234ae 100644 --- a/src/esx/esx_vi_methods.c +++ b/src/esx/esx_vi_methods.c @@ -304,7 +304,7 @@ ESX_VI__METHOD(RetrieveProperties, (esxVI_Context *ctx, esxVI_PropertyFilterSpec *specSet, /* list */ esxVI_ObjectContent **objectContentList), - List, + OptionalList, { ESX_VI__METHOD__CHECK_SERVICE() ESX_VI__METHOD__PARAMETER__CHECK_OUTPUT(objectContentList) @@ -344,8 +344,7 @@ ESX_VI__METHOD(PowerOnVM_Task, virtualMachine) }, { - if (esxVI_ManagedObjectReference_Deserialize(response->node, task, - "Task") < 0) { + if (esxVI_ManagedObjectReference_Deserialize(response->node, task) < 0) { goto failure; } }) @@ -369,8 +368,7 @@ ESX_VI__METHOD(PowerOffVM_Task, virtualMachine) }, { - if (esxVI_ManagedObjectReference_Deserialize(response->node, task, - "Task") < 0) { + if (esxVI_ManagedObjectReference_Deserialize(response->node, task) < 0) { goto failure; } }) @@ -394,8 +392,7 @@ ESX_VI__METHOD(SuspendVM_Task, virtualMachine) }, { - if (esxVI_ManagedObjectReference_Deserialize(response->node, task, - "Task") < 0) { + if (esxVI_ManagedObjectReference_Deserialize(response->node, task) < 0) { goto failure; } }) @@ -428,8 +425,7 @@ ESX_VI__METHOD(MigrateVM_Task, ESX_VI__METHOD__PARAMETER__SERIALIZE(VirtualMachinePowerState, state) }, { - if (esxVI_ManagedObjectReference_Deserialize(response->node, task, - "Task") < 0) { + if (esxVI_ManagedObjectReference_Deserialize(response->node, task) < 0) { goto failure; } }) @@ -456,8 +452,7 @@ ESX_VI__METHOD(ReconfigVM_Task, ESX_VI__METHOD__PARAMETER__SERIALIZE(VirtualMachineConfigSpec, spec) }, { - if (esxVI_ManagedObjectReference_Deserialize(response->node, task, - "Task") < 0) { + if (esxVI_ManagedObjectReference_Deserialize(response->node, task) < 0) { goto failure; } }) @@ -490,8 +485,7 @@ ESX_VI__METHOD(RegisterVM_Task, ESX_VI__METHOD__PARAMETER__SERIALIZE(ManagedObjectReference, host) }, { - if (esxVI_ManagedObjectReference_Deserialize(response->node, task, - "Task") < 0) { + if (esxVI_ManagedObjectReference_Deserialize(response->node, task) < 0) { goto failure; } }) @@ -583,8 +577,8 @@ ESX_VI__METHOD(CreateFilter, ESX_VI__METHOD__PARAMETER__SERIALIZE(Boolean, partialUpdates) }, { - if (esxVI_ManagedObjectReference_Deserialize(response->node, propertyFilter, - "PropertyFilter") < 0) { + if (esxVI_ManagedObjectReference_Deserialize(response->node, + propertyFilter) < 0) { goto failure; } }) @@ -684,7 +678,7 @@ ESX_VI__METHOD(ValidateMigration, esxVI_ManagedObjectReference *pool, esxVI_ManagedObjectReference *host, esxVI_Event **eventList), - List, + OptionalList, { ESX_VI__METHOD__PARAMETER__CHECK_OUTPUT(eventList) }, @@ -736,10 +730,8 @@ ESX_VI__METHOD(FindByIp, ESX_VI__METHOD__PARAMETER__SERIALIZE(Boolean, vmSearch) }, { - if (esxVI_ManagedObjectReference_Deserialize - (response->node, managedObjectReference, - vmSearch == esxVI_Boolean_True ? "VirtualMachine" - : "HostSystem") < 0) { + if (esxVI_ManagedObjectReference_Deserialize(response->node, + managedObjectReference) < 0) { goto failure; } }) @@ -771,10 +763,8 @@ ESX_VI__METHOD(FindByUuid, ESX_VI__METHOD__PARAMETER__SERIALIZE(Boolean, vmSearch) }, { - if (esxVI_ManagedObjectReference_Deserialize - (response->node, managedObjectReference, - vmSearch == esxVI_Boolean_True ? "VirtualMachine" - : "HostSystem") < 0) { + if (esxVI_ManagedObjectReference_Deserialize(response->node, + managedObjectReference) < 0) { goto failure; } }) @@ -789,7 +779,7 @@ ESX_VI__METHOD(QueryAvailablePerfMetric, esxVI_DateTime *endTime, esxVI_Int *intervalId, esxVI_PerfMetricId **perfMetricIdList), - List, + OptionalList, { ESX_VI__METHOD__CHECK_SERVICE() ESX_VI__METHOD__PARAMETER__CHECK_OUTPUT(perfMetricIdList) @@ -820,7 +810,7 @@ ESX_VI__METHOD(QueryPerfCounter, (esxVI_Context *ctx, esxVI_Int *counterId, /* list */ esxVI_PerfCounterInfo **perfCounterInfoList), - List, + OptionalList, { ESX_VI__METHOD__CHECK_SERVICE() ESX_VI__METHOD__PARAMETER__CHECK_OUTPUT(perfCounterInfoList) @@ -848,7 +838,7 @@ ESX_VI__METHOD(QueryPerf, (esxVI_Context *ctx, esxVI_PerfQuerySpec *querySpec, /* list */ esxVI_PerfEntityMetric **perfEntityMetricList), - List, + OptionalList, { ESX_VI__METHOD__CHECK_SERVICE() ESX_VI__METHOD__PARAMETER__CHECK_OUTPUT(perfEntityMetricList) diff --git a/src/esx/esx_vi_types.c b/src/esx/esx_vi_types.c index 87a13cb..6f257b2 100644 --- a/src/esx/esx_vi_types.c +++ b/src/esx/esx_vi_types.c @@ -64,11 +64,17 @@ -#define ESX_VI__TEMPLATE__ALLOC(_type) \ +#define ESX_VI__TEMPLATE__ALLOC(__type) \ int \ - esxVI_##_type##_Alloc(esxVI_##_type **ptrptr) \ + esxVI_##__type##_Alloc(esxVI_##__type **ptrptr) \ { \ - return esxVI_Alloc((void **)ptrptr, sizeof(esxVI_##_type)); \ + if (esxVI_Alloc((void **)ptrptr, sizeof (esxVI_##__type)) < 0) { \ + return -1; \ + } \ + \ + (*ptrptr)->_type = esxVI_Type_##__type; \ + \ + return 0; \ } @@ -92,11 +98,18 @@ -#define ESX_VI__TEMPLATE__VALIDATE(_type, _require) \ +#define ESX_VI__TEMPLATE__VALIDATE(__type, _require) \ int \ - esxVI_##_type##_Validate(esxVI_##_type *item) \ + esxVI_##__type##_Validate(esxVI_##__type *item) \ { \ - const char *type_name = #_type; \ + const char *type_name = esxVI_Type_ToString(esxVI_Type_##__type); \ + \ + if (item->_type <= esxVI_Type_Undefined || \ + item->_type >= esxVI_Type_Other) { \ + ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, \ + "%s object has invalid dynamic type", type_name); \ + return -1; \ + } \ \ _require \ \ @@ -105,11 +118,31 @@ -#define ESX_VI__TEMPLATE__VALIDATE_NOOP(_type) \ +#define ESX_VI__TEMPLATE__DEEP_COPY(_type, _deep_copy) \ int \ - esxVI_##_type##_Validate(esxVI_##_type *item ATTRIBUTE_UNUSED) \ + esxVI_##_type##_DeepCopy(esxVI_##_type **dest, esxVI_##_type *src) \ { \ + if (dest == NULL || *dest != NULL) { \ + ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, "Invalid argument"); \ + return -1; \ + } \ + \ + if (src == NULL) { \ + return 0; \ + } \ + \ + if (esxVI_##_type##_Alloc(dest) < 0) { \ + goto failure; \ + } \ + \ + _deep_copy \ + \ return 0; \ + \ + failure: \ + esxVI_##_type##_Free(dest); \ + \ + return -1; \ } @@ -184,19 +217,20 @@ return -1; \ } \ \ - if (STRNEQ(anyType->other, #_type)) { \ + if (anyType->type != esxVI_Type_##_type) { \ ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, \ "Expecting type '%s' but found '%s'", \ - #_type, anyType->other); \ + esxVI_Type_ToString(esxVI_Type_##_type), \ + anyType->other); \ return -1; \ } \ \ - return esxVI_##_type##_Deserialize(anyType->_node, ptrptr); \ + return esxVI_##_type##_Deserialize(anyType->node, ptrptr); \ } -#define ESX_VI__TEMPLATE__SERIALIZE_EXTRA(_type, _type_string, _serialize) \ +#define ESX_VI__TEMPLATE__SERIALIZE_EXTRA(_type, _extra, _serialize) \ int \ esxVI_##_type##_Serialize(esxVI_##_type *item, \ const char *element, virBufferPtr output) \ @@ -210,11 +244,14 @@ return 0; \ } \ \ + _extra \ + \ if (esxVI_##_type##_Validate(item) < 0) { \ return -1; \ } \ \ - ESV_VI__XML_TAG__OPEN(output, element, _type_string); \ + ESV_VI__XML_TAG__OPEN(output, element, \ + esxVI_Type_ToString(esxVI_Type_##_type)); \ \ _serialize \ \ @@ -226,7 +263,7 @@ #define ESX_VI__TEMPLATE__SERIALIZE(_type, _serialize) \ - ESX_VI__TEMPLATE__SERIALIZE_EXTRA(_type, #_type, _serialize) + ESX_VI__TEMPLATE__SERIALIZE_EXTRA(_type, /* nothing */, _serialize) @@ -328,6 +365,31 @@ +/* + * Macros for property handling to be used as part of other macros + */ + +#define ESX_VI__TEMPLATE__PROPERTY__DEEP_COPY(_type, _name) \ + if (esxVI_##_type##_DeepCopy(&(*dest)->_name, src->_name) < 0) { \ + goto failure; \ + } + + + +#define ESX_VI__TEMPLATE__PROPERTY__DEEP_COPY_LIST(_type, _name) \ + if (esxVI_##_type##_DeepCopyList(&(*dest)->_name, src->_name) < 0) { \ + goto failure; \ + } + + + +#define ESX_VI__TEMPLATE__PROPERTY__DEEP_COPY_VALUE(_type, _name) \ + if (esxVI_##_type##_DeepCopyValue(&(*dest)->_name, src->_name) < 0) { \ + goto failure; \ + } + + + #define ESX_VI__TEMPLATE__PROPERTY__SERIALIZE(_type, _name) \ if (esxVI_##_type##_Serialize(item->_name, #_name, output) < 0) { \ return -1; \ @@ -360,23 +422,17 @@ -#define ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(_type, _name) \ +#define ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_IGNORE(_name) \ if (xmlStrEqual(childNode->name, BAD_CAST #_name)) { \ - if (esxVI_##_type##_DeserializeValue(childNode, \ - &(*ptrptr)->_name) < 0) { \ - goto failure; \ - } \ - \ continue; \ } -#define ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(_type, _expected, \ - _name) \ +#define ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(_type, _name) \ if (xmlStrEqual(childNode->name, BAD_CAST #_name)) { \ - if (esxVI_##_type##_Deserialize(childNode, &(*ptrptr)->_name, \ - _expected) < 0) { \ + if (esxVI_##_type##_DeserializeValue(childNode, \ + &(*ptrptr)->_name) < 0) { \ goto failure; \ } \ \ @@ -385,13 +441,6 @@ -#define ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_NOOP(_name) \ - if (xmlStrEqual(childNode->name, BAD_CAST #_name)) { \ - continue; \ - } - - - #define ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_LIST(_type, _name) \ if (xmlStrEqual(childNode->name, BAD_CAST #_name)) { \ esxVI_##_type *_name##Item = NULL; \ @@ -427,6 +476,10 @@ +/* + * Macros to implement enumerations + */ + #define ESX_VI__TEMPLATE__ENUMERATION__CAST_FROM_ANY_TYPE(_type) \ int \ esxVI_##_type##_CastFromAnyType(esxVI_AnyType *anyType, \ @@ -459,20 +512,102 @@ +/* + * Macros to implement dynamic dispatched functions + */ + +#define ESX_VI__TEMPLATE__DISPATCH(__type, _dispatch, _error_return) \ + switch (item->_type) { \ + _dispatch \ + \ + case esxVI_Type_##__type: \ + break; \ + \ + default: \ + ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, \ + "Call to %s for unexpected type '%s'", __FUNCTION__, \ + esxVI_Type_ToString(item->_type)); \ + return _error_return; \ + } + + + +#define ESX_VI__TEMPLATE__DISPATCH__FREE(_type) \ + case esxVI_Type_##_type: \ + esxVI_##_type##_Free((esxVI_##_type **)ptrptr); \ + return; + + + +#define ESX_VI__TEMPLATE__DISPATCH__DEEP_COPY(_type) \ + case esxVI_Type_##_type: \ + return esxVI_##_type##_DeepCopy((esxVI_##_type **)dst, \ + (esxVI_##_type *)src); + + + +#define ESX_VI__TEMPLATE__DISPATCH__SERIALIZE(_type) \ + case esxVI_Type_##_type: \ + return esxVI_##_type##_Serialize((esxVI_##_type *)item, element, \ + output); + + + +#define ESX_VI__TEMPLATE__DYNAMIC_FREE(__type, _dispatch, _body) \ + ESX_VI__TEMPLATE__FREE(__type, \ + ESX_VI__TEMPLATE__DISPATCH(__type, _dispatch, /* nothing */) \ + _body) + + + +#define ESX_VI__TEMPLATE__DYNAMIC_CAST(__type, _accept) \ + esxVI_##__type * \ + esxVI_##__type##_DynamicCast(void *item) \ + { \ + if (item == NULL) { \ + ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, "Invalid argument"); \ + return NULL; \ + } \ + \ + _accept \ + \ + return NULL; \ + } + + + +#define ESX_VI__TEMPLATE__DYNAMIC_CAST__ACCEPT(__type) \ + if (((esxVI_Object *)item)->_type == esxVI_Type_##__type) { \ + return item; \ + } + + + +#define ESX_VI__TEMPLATE__DYNAMIC_SERIALIZE(__type, _dispatch, _serialize) \ + ESX_VI__TEMPLATE__SERIALIZE_EXTRA(__type, \ + ESX_VI__TEMPLATE__DISPATCH(__type, _dispatch, -1), \ + _serialize) + + + /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * XSI: Type */ const char * -esxVI_Type_Name(esxVI_Type type) +esxVI_Type_ToString(esxVI_Type type) { switch (type) { + default: case esxVI_Type_Undefined: - return "undefined"; + return "<undefined>"; case esxVI_Type_Boolean: return "xsd:boolean"; + case esxVI_Type_AnyType: + return "xsd:anyType"; + case esxVI_Type_String: return "xsd:string"; @@ -485,14 +620,53 @@ esxVI_Type_Name(esxVI_Type type) case esxVI_Type_Long: return "xsd:long"; - case esxVI_Type_Other: - return "other"; + case esxVI_Type_DateTime: + return "xsd:dateTime"; - default: - return "unknown"; + case esxVI_Type_Fault: + return "Fault"; + + case esxVI_Type_ManagedObjectReference: + return "ManagedObjectReference"; + +#include "esx_vi_types.generated.typetostring" + + case esxVI_Type_Other: + return "<other>"; } } +esxVI_Type +esxVI_Type_FromString(const char *type) +{ + if (type == NULL || STREQ(type, "<undefined>")) { + return esxVI_Type_Undefined; + } else if (STREQ(type, "xsd:boolean")) { + return esxVI_Type_Boolean; + } else if (STREQ(type, "xsd:anyType")) { + return esxVI_Type_AnyType; + } else if (STREQ(type, "xsd:string")) { + return esxVI_Type_String; + } else if (STREQ(type, "xsd:short")) { + return esxVI_Type_Short; + } else if (STREQ(type, "xsd:int")) { + return esxVI_Type_Int; + } else if (STREQ(type, "xsd:long")) { + return esxVI_Type_Long; + } else if (STREQ(type, "xsd:dateTime")) { + return esxVI_Type_DateTime; + } else if (STREQ(type, "Fault")) { + return esxVI_Type_Fault; + } else if (STREQ(type, "ManagedObjectReference")) { + return esxVI_Type_ManagedObjectReference; + } + +#include "esx_vi_types.generated.typefromstring" + + else { + return esxVI_Type_Other; + } +} /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * @@ -500,7 +674,7 @@ esxVI_Type_Name(esxVI_Type type) */ static const esxVI_Enumeration _esxVI_Boolean_Enumeration = { - "xsd:boolean", { + esxVI_Type_Boolean, { { "true", esxVI_Boolean_True }, { "false", esxVI_Boolean_False }, { NULL, -1 }, @@ -525,7 +699,7 @@ ESX_VI__TEMPLATE__ALLOC(AnyType); /* esxVI_AnyType_Free */ ESX_VI__TEMPLATE__FREE(AnyType, { - xmlFreeNode(item->_node); + xmlFreeNode(item->node); VIR_FREE(item->other); VIR_FREE(item->value); }); @@ -536,9 +710,9 @@ esxVI_AnyType_ExpectType(esxVI_AnyType *anyType, esxVI_Type type) if (anyType->type != type) { ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, "Expecting type '%s' but found '%s'", - esxVI_Type_Name(type), + esxVI_Type_ToString(type), anyType->type != esxVI_Type_Other - ? esxVI_Type_Name(anyType->type) + ? esxVI_Type_ToString(anyType->type) : anyType->other); return -1; } @@ -562,9 +736,10 @@ esxVI_AnyType_DeepCopy(esxVI_AnyType **dest, esxVI_AnyType *src) goto failure; } - (*dest)->_node = xmlCopyNode(src->_node, 1); + (*dest)->_type = src->_type; + (*dest)->node = xmlCopyNode(src->node, 1); - if ((*dest)->_node == NULL) { + if ((*dest)->node == NULL) { ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, "Could not copy an XML node"); goto failure; } @@ -612,7 +787,7 @@ esxVI_AnyType_DeepCopy(esxVI_AnyType **dest, esxVI_AnyType *src) int esxVI_AnyType_Deserialize(xmlNodePtr node, esxVI_AnyType **anyType) { - long long number; + long long int number; if (anyType == NULL || *anyType != NULL) { ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, "Invalid argument"); @@ -623,9 +798,9 @@ esxVI_AnyType_Deserialize(xmlNodePtr node, esxVI_AnyType **anyType) return -1; } - (*anyType)->_node = xmlCopyNode(node, 1); + (*anyType)->node = xmlCopyNode(node, 1); - if ((*anyType)->_node == NULL) { + if ((*anyType)->node == NULL) { ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, "Could not copy an XML node"); goto failure; } @@ -641,6 +816,15 @@ esxVI_AnyType_Deserialize(xmlNodePtr node, esxVI_AnyType **anyType) goto failure; } + (*anyType)->type = esxVI_Type_FromString((*anyType)->other); + + if ((*anyType)->type == esxVI_Type_Undefined) { + ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, + "Unknown value '%s' for AnyType 'type' property", + (*anyType)->other); + goto failure; + } + (*anyType)->value = (char *)xmlNodeListGetString(node->doc, node->children, 1); @@ -669,13 +853,11 @@ esxVI_AnyType_Deserialize(xmlNodePtr node, esxVI_AnyType **anyType) goto failure; \ } \ \ - (*anyType)->type = esxVI_Type_##_type; \ (*anyType)->_name = number; \ } while (0) - if (STREQ((*anyType)->other, "xsd:boolean")) { - (*anyType)->type = esxVI_Type_Boolean; - + switch ((*anyType)->type) { + case esxVI_Type_Boolean: if (STREQ((*anyType)->value, "true")) { (*anyType)->boolean = esxVI_Boolean_True; } else if (STREQ((*anyType)->value, "false")) { @@ -686,15 +868,27 @@ esxVI_AnyType_Deserialize(xmlNodePtr node, esxVI_AnyType **anyType) (*anyType)->value); goto failure; } - } else if (STREQ((*anyType)->other, "xsd:string")) { - (*anyType)->type = esxVI_Type_String; + + break; + + case esxVI_Type_String: (*anyType)->string = (*anyType)->value; - } else if (STREQ((*anyType)->other, "xsd:short")) { + break; + + case esxVI_Type_Short: _DESERIALIZE_NUMBER(Short, "xsd:short", int16, INT16_MIN, INT16_MAX); - } else if (STREQ((*anyType)->other, "xsd:int")) { + break; + + case esxVI_Type_Int: _DESERIALIZE_NUMBER(Int, "xsd:int", int32, INT32_MIN, INT32_MAX); - } else if (STREQ((*anyType)->other, "xsd:long")) { + break; + + case esxVI_Type_Long: _DESERIALIZE_NUMBER(Long, "xsd:long", int64, INT64_MIN, INT64_MAX); + break; + + default: + break; } #undef _DESERIALIZE_NUMBER @@ -724,6 +918,12 @@ ESX_VI__TEMPLATE__FREE(String, VIR_FREE(item->value); }); +/* esxVI_String_Validate */ +ESX_VI__TEMPLATE__VALIDATE(String, +{ + ESX_VI__TEMPLATE__PROPERTY__REQUIRE(value) +}) + /* esxVI_String_AppendToList */ ESX_VI__TEMPLATE__LIST__APPEND(String); @@ -782,30 +982,11 @@ esxVI_String_AppendValueListToList(esxVI_String **stringList, return -1; } -int -esxVI_String_DeepCopy(esxVI_String **dest, esxVI_String *src) +/* esxVI_String_DeepCopy */ +ESX_VI__TEMPLATE__DEEP_COPY(String, { - if (dest == NULL || *dest != NULL) { - ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, "Invalid argument"); - return -1; - } - - if (src == NULL) { - return 0; - } - - if (esxVI_String_Alloc(dest) < 0 || - esxVI_String_DeepCopyValue(&(*dest)->value, src->value)) { - goto failure; - } - - return 0; - - failure: - esxVI_String_Free(dest); - - return -1; -} + ESX_VI__TEMPLATE__PROPERTY__DEEP_COPY_VALUE(String, value) +}) /* esxVI_String_DeepCopyList */ ESX_VI__TEMPLATE__LIST__DEEP_COPY(String); @@ -865,37 +1046,11 @@ esxVI_String_SerializeValue(const char *value, const char *element, return 0; } -int -esxVI_String_Deserialize(xmlNodePtr node, esxVI_String **string) +/* esxVI_String_Deserialize */ +ESX_VI__TEMPLATE__DESERIALIZE(String, { - if (string == NULL || *string != NULL) { - ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, "Invalid argument"); - return -1; - } - - if (esxVI_String_Alloc(string) < 0) { - return -1; - } - - (*string)->value = - (char *)xmlNodeListGetString(node->doc, node->children, 1); - - if ((*string)->value == NULL) { - (*string)->value = strdup(""); - - if ((*string)->value == NULL) { - virReportOOMError(); - goto failure; - } - } - - return 0; - - failure: - esxVI_String_Free(string); - - return -1; -} + ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, value) +}) /* esxVI_String_DeserializeList */ ESX_VI__TEMPLATE__LIST__DESERIALIZE(String); @@ -938,39 +1093,21 @@ ESX_VI__TEMPLATE__FREE(Int, }); /* esxVI_Int_Validate */ -ESX_VI__TEMPLATE__VALIDATE_NOOP(Int); +ESX_VI__TEMPLATE__VALIDATE(Int, +{ +}) /* esxVI_Int_AppendToList */ ESX_VI__TEMPLATE__LIST__APPEND(Int); -int -esxVI_Int_DeepCopy(esxVI_Int **dest, esxVI_Int *src) +/* esxVI_Int_DeepCopy */ +ESX_VI__TEMPLATE__DEEP_COPY(Int, { - if (dest == NULL || *dest != NULL) { - ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, "Invalid argument"); - return -1; - } - - if (src == NULL) { - return 0; - } - - if (esxVI_Int_Alloc(dest) < 0) { - goto failure; - } - (*dest)->value = src->value; - - return 0; - - failure: - esxVI_Int_Free(dest); - - return -1; -} +}) /* esxVI_Int_Serialize */ -ESX_VI__TEMPLATE__SERIALIZE_EXTRA(Int, "xsd:int", +ESX_VI__TEMPLATE__SERIALIZE(Int, { virBufferVSprintf(output, "%d", (int)item->value); }); @@ -997,13 +1134,15 @@ ESX_VI__TEMPLATE__FREE(Long, }); /* esxVI_Long_Validate */ -ESX_VI__TEMPLATE__VALIDATE_NOOP(Long); +ESX_VI__TEMPLATE__VALIDATE(Long, +{ +}) /* esxVI_Long_AppendToList */ ESX_VI__TEMPLATE__LIST__APPEND(Long); /* esxVI_Long_Serialize */ -ESX_VI__TEMPLATE__SERIALIZE_EXTRA(Long, "xsd:long", +ESX_VI__TEMPLATE__SERIALIZE(Long, { virBufferVSprintf(output, "%lld", (long long int)item->value); }); @@ -1036,7 +1175,7 @@ ESX_VI__TEMPLATE__VALIDATE(DateTime, }); /* esxVI_DateTime_Serialize */ -ESX_VI__TEMPLATE__SERIALIZE_EXTRA(DateTime, "xsd:dateTime", +ESX_VI__TEMPLATE__SERIALIZE(DateTime, { virBufferAdd(output, item->value, -1); }); @@ -1074,184 +1213,6 @@ esxVI_DateTime_Deserialize(xmlNodePtr node, esxVI_DateTime **dateTime) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Enum: ManagedEntityStatus - */ - -static const esxVI_Enumeration _esxVI_ManagedEntityStatus_Enumeration = { - "ManagedEntityStatus", { - { "gray", esxVI_ManagedEntityStatus_Gray }, - { "green", esxVI_ManagedEntityStatus_Green }, - { "yellow", esxVI_ManagedEntityStatus_Yellow }, - { "red", esxVI_ManagedEntityStatus_Red }, - { NULL, -1 }, - }, -}; - -/* esxVI_ManagedEntityStatus_CastFromAnyType */ -ESX_VI__TEMPLATE__ENUMERATION__CAST_FROM_ANY_TYPE(ManagedEntityStatus); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Enum: ObjectUpdateKind - */ - -static const esxVI_Enumeration _esxVI_ObjectUpdateKind_Enumeration = { - "ObjectUpdateKind", { - { "enter", esxVI_ObjectUpdateKind_Enter }, - { "leave", esxVI_ObjectUpdateKind_Leave }, - { "modify", esxVI_ObjectUpdateKind_Modify }, - { NULL, -1 }, - }, -}; - -/* esxVI_ObjectUpdateKind_Deserialize */ -ESX_VI__TEMPLATE__ENUMERATION__DESERIALIZE(ObjectUpdateKind); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Enum: PerfSummaryType - */ - -static const esxVI_Enumeration _esxVI_PerfSummaryType_Enumeration = { - "PerfSummaryType", { - { "average", esxVI_PerfSummaryType_Average }, - { "latest", esxVI_PerfSummaryType_Latest }, - { "maximum", esxVI_PerfSummaryType_Maximum }, - { "minimum", esxVI_PerfSummaryType_Minimum }, - { "none", esxVI_PerfSummaryType_None }, - { "summation", esxVI_PerfSummaryType_Summation }, - { NULL, -1 }, - }, -}; - -/* esxVI_PerfSummaryType_Deserialize */ -ESX_VI__TEMPLATE__ENUMERATION__DESERIALIZE(PerfSummaryType); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Enum: PerfStatsType - */ - -static const esxVI_Enumeration _esxVI_PerfStatsType_Enumeration = { - "PerfStatsType", { - { "absolute", esxVI_PerfStatsType_Absolute }, - { "delta", esxVI_PerfStatsType_Delta }, - { "rate", esxVI_PerfStatsType_Rate }, - { NULL, -1 }, - }, -}; - -/* esxVI_PerfStatsType_Deserialize */ -ESX_VI__TEMPLATE__ENUMERATION__DESERIALIZE(PerfStatsType); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Enum: PropertyChangeOp - */ - -static const esxVI_Enumeration _esxVI_PropertyChangeOp_Enumeration = { - "PropertyChangeOp", { - { "add", esxVI_PropertyChangeOp_Add }, - { "remove", esxVI_PropertyChangeOp_Remove }, - { "assign", esxVI_PropertyChangeOp_Assign }, - { "indirectRemove", esxVI_PropertyChangeOp_IndirectRemove }, - { NULL, -1 }, - }, -}; - -/* esxVI_PropertyChangeOp_Deserialize */ -ESX_VI__TEMPLATE__ENUMERATION__DESERIALIZE(PropertyChangeOp); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Enum: SharesLevel - */ - -static const esxVI_Enumeration _esxVI_SharesLevel_Enumeration = { - "SharesLevel", { - { "custom", esxVI_SharesLevel_Custom }, - { "high", esxVI_SharesLevel_High }, - { "low", esxVI_SharesLevel_Low }, - { "normal", esxVI_SharesLevel_Normal }, - { NULL, -1 }, - }, -}; - -/* esxVI_SharesLevel_Serialize */ -ESX_VI__TEMPLATE__ENUMERATION__SERIALIZE(SharesLevel); - -/* esxVI_SharesLevel_Deserialize */ -ESX_VI__TEMPLATE__ENUMERATION__DESERIALIZE(SharesLevel); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Enum: TaskInfoState - */ - -static const esxVI_Enumeration _esxVI_TaskInfoState_Enumeration = { - "TaskInfoState", { - { "error", esxVI_TaskInfoState_Error }, - { "queued", esxVI_TaskInfoState_Queued }, - { "running", esxVI_TaskInfoState_Running }, - { "success", esxVI_TaskInfoState_Success }, - { NULL, -1 }, - }, -}; - -/* esxVI_TaskInfoState_CastFromAnyType */ -ESX_VI__TEMPLATE__ENUMERATION__CAST_FROM_ANY_TYPE(TaskInfoState); - -/* esxVI_TaskInfoState_Deserialize */ -ESX_VI__TEMPLATE__ENUMERATION__DESERIALIZE(TaskInfoState); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Enum: VirtualMachineMovePriority - */ - -static const esxVI_Enumeration _esxVI_VirtualMachineMovePriority_Enumeration = { - "VirtualMachineMovePriority", { - { "lowPriority", esxVI_VirtualMachineMovePriority_LowPriority }, - { "highPriority", esxVI_VirtualMachineMovePriority_HighPriority }, - { "defaultPriority", esxVI_VirtualMachineMovePriority_DefaultPriority }, - { NULL, -1 }, - }, -}; - -/* esxVI_VirtualMachineMovePriority_Serialize */ -ESX_VI__TEMPLATE__ENUMERATION__SERIALIZE(VirtualMachineMovePriority); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Enum: VirtualMachinePowerState - */ - -static const esxVI_Enumeration _esxVI_VirtualMachinePowerState_Enumeration = { - "VirtualMachinePowerState", { - { "poweredOff", esxVI_VirtualMachinePowerState_PoweredOff }, - { "poweredOn", esxVI_VirtualMachinePowerState_PoweredOn }, - { "suspended", esxVI_VirtualMachinePowerState_Suspended }, - { NULL, -1 }, - }, -}; - -/* esxVI_VirtualMachinePowerState_CastFromAnyType */ -ESX_VI__TEMPLATE__ENUMERATION__CAST_FROM_ANY_TYPE(VirtualMachinePowerState); - -/* esxVI_VirtualMachinePowerState_Serialize */ -ESX_VI__TEMPLATE__ENUMERATION__SERIALIZE(VirtualMachinePowerState); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * VI Type: Fault */ @@ -1277,7 +1238,7 @@ ESX_VI__TEMPLATE__DESERIALIZE(Fault, { ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, faultcode); ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, faultstring); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_NOOP(detail); /* FIXME */ + ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_IGNORE(detail); /* FIXME */ }); @@ -1298,128 +1259,21 @@ ESX_VI__TEMPLATE__FREE(ManagedObjectReference, VIR_FREE(item->value); }); -int -esxVI_ManagedObjectReference_DeepCopy(esxVI_ManagedObjectReference **dest, - esxVI_ManagedObjectReference *src) +/* esxVI_ManagedObjectReference_DeepCopy */ +ESX_VI__TEMPLATE__DEEP_COPY(ManagedObjectReference, { - if (dest == NULL || *dest != NULL) { - ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, "Invalid argument"); - return -1; - } - - if (src == NULL) { - return 0; - } - - if (esxVI_ManagedObjectReference_Alloc(dest) < 0 || - esxVI_String_DeepCopyValue(&(*dest)->type, src->type) < 0 || - esxVI_String_DeepCopyValue(&(*dest)->value, src->value) < 0) { - goto failure; - } - - return 0; - - failure: - esxVI_ManagedObjectReference_Free(dest); - - return -1; -} + ESX_VI__TEMPLATE__PROPERTY__DEEP_COPY_VALUE(String, type) + ESX_VI__TEMPLATE__PROPERTY__DEEP_COPY_VALUE(String, value) +}) /* esxVI_ManagedObjectReference_AppendToList */ ESX_VI__TEMPLATE__LIST__APPEND(ManagedObjectReference); -int -esxVI_ManagedObjectReference_CastFromAnyType - (esxVI_AnyType *anyType, - esxVI_ManagedObjectReference **managedObjectReference, - const char *expectedType) -{ - if (anyType == NULL || managedObjectReference == NULL || - *managedObjectReference != NULL) { - ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, "Invalid argument"); - return -1; - } - - if (STRNEQ(anyType->other, "ManagedObjectReference")) { - ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, - "Expecting type 'ManagedObjectReference' but found '%s'", - anyType->other); - return -1; - } - - return esxVI_ManagedObjectReference_Deserialize(anyType->_node, - managedObjectReference, - expectedType); -} - -int -esxVI_ManagedObjectReference_CastListFromAnyType - (esxVI_AnyType *anyType, - esxVI_ManagedObjectReference **managedObjectReferenceList, - const char *expectedType) -{ - int result = 0; - xmlNodePtr childNode = NULL; - esxVI_AnyType *childAnyType = NULL; - esxVI_ManagedObjectReference *managedObjectReference = NULL; - - if (managedObjectReferenceList == NULL || - *managedObjectReferenceList != NULL) { - ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, "Invalid argument"); - goto failure; - } - - if (anyType == NULL) { - return 0; - } - - if (STRNEQ(anyType->other, "ArrayOfManagedObjectReference")) { - ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, - "Expecting type to be 'ArrayOfManagedObjectReference' " - "but found '%s'", anyType->other); - goto failure; - } - - for (childNode = anyType->_node->children; childNode != NULL; - childNode = childNode->next) { - if (childNode->type != XML_ELEMENT_NODE) { - ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, - "Wrong XML element type %d", childNode->type); - goto failure; - } - - esxVI_AnyType_Free(&childAnyType); - - if (esxVI_AnyType_Deserialize(childNode, &childAnyType) < 0) { - goto failure; - } - - managedObjectReference = NULL; - - if (esxVI_ManagedObjectReference_CastFromAnyType - (childAnyType, &managedObjectReference, expectedType) < 0) { - goto failure; - } - - if (esxVI_ManagedObjectReference_AppendToList - (managedObjectReferenceList, managedObjectReference) < 0) { - goto failure; - } - } - +/* esxVI_ManagedObjectReference_CastFromAnyType */ +ESX_VI__TEMPLATE__CAST_FROM_ANY_TYPE(ManagedObjectReference) - cleanup: - esxVI_AnyType_Free(&childAnyType); - - return result; - - failure: - esxVI_ManagedObjectReference_Free(managedObjectReferenceList); - - result = -1; - - goto cleanup; -} +/* esxVI_ManagedObjectReference_CastListFromAnyType */ +ESX_VI__TEMPLATE__LIST__CAST_FROM_ANY_TYPE(ManagedObjectReference) int esxVI_ManagedObjectReference_Serialize @@ -1454,8 +1308,7 @@ ESX_VI__TEMPLATE__LIST__SERIALIZE(ManagedObjectReference); int esxVI_ManagedObjectReference_Deserialize - (xmlNodePtr node, esxVI_ManagedObjectReference **managedObjectReference, - const char *expectedType) + (xmlNodePtr node, esxVI_ManagedObjectReference **managedObjectReference) { if (managedObjectReference == NULL || *managedObjectReference != NULL) { ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, "Invalid argument"); @@ -1475,14 +1328,6 @@ esxVI_ManagedObjectReference_Deserialize goto failure; } - if (expectedType != NULL && - STRNEQ(expectedType, (*managedObjectReference)->type)) { - ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, - "Expected type '%s' but found '%s'", expectedType, - (*managedObjectReference)->type); - goto failure; - } - if (esxVI_String_DeserializeValue(node, &(*managedObjectReference)->value) < 0) { goto failure; @@ -1496,1533 +1341,4 @@ esxVI_ManagedObjectReference_Deserialize return -1; } - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: DynamicProperty - */ - -/* esxVI_DynamicProperty_Alloc */ -ESX_VI__TEMPLATE__ALLOC(DynamicProperty); - -/* esxVI_DynamicProperty_Free */ -ESX_VI__TEMPLATE__FREE(DynamicProperty, -{ - esxVI_DynamicProperty_Free(&item->_next); - - VIR_FREE(item->name); - esxVI_AnyType_Free(&item->val); -}); - -/* esxVI_DynamicProperty_Validate */ -ESX_VI__TEMPLATE__VALIDATE(DynamicProperty, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(name); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(val); -}); - -int -esxVI_DynamicProperty_DeepCopy(esxVI_DynamicProperty **dest, - esxVI_DynamicProperty *src) -{ - if (dest == NULL || *dest != NULL) { - ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, "Invalid argument"); - return -1; - } - - if (src == NULL) { - return 0; - } - - if (esxVI_DynamicProperty_Alloc(dest) < 0 || - esxVI_String_DeepCopyValue(&(*dest)->name, src->name) < 0 || - esxVI_AnyType_DeepCopy(&(*dest)->val, src->val) < 0) { - goto failure; - } - - return 0; - - failure: - esxVI_DynamicProperty_Free(dest); - - return -1; -} - -/* esxVI_DynamicProperty_DeepCopyList */ -ESX_VI__TEMPLATE__LIST__DEEP_COPY(DynamicProperty); - -/* esxVI_DynamicProperty_AppendToList */ -ESX_VI__TEMPLATE__LIST__APPEND(DynamicProperty); - -/* esxVI_DynamicProperty_Deserialize */ -ESX_VI__TEMPLATE__DESERIALIZE(DynamicProperty, -{ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, name); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(AnyType, val); -}); - -/* esxVI_DynamicProperty_DeserializeList */ -ESX_VI__TEMPLATE__LIST__DESERIALIZE(DynamicProperty); - - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: HostCpuIdInfo - */ - -/* esxVI_HostCpuIdInfo_Alloc */ -ESX_VI__TEMPLATE__ALLOC(HostCpuIdInfo); - -/* esxVI_HostCpuIdInfo_Free */ -ESX_VI__TEMPLATE__FREE(HostCpuIdInfo, -{ - esxVI_HostCpuIdInfo_Free(&item->_next); - - esxVI_Int_Free(&item->level); - VIR_FREE(item->vendor); - VIR_FREE(item->eax); - VIR_FREE(item->ebx); - VIR_FREE(item->ecx); - VIR_FREE(item->edx); -}); - -/* esxVI_HostCpuIdInfo_Validate */ -ESX_VI__TEMPLATE__VALIDATE(HostCpuIdInfo, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(level); -}); - -/* esxVI_HostCpuIdInfo_CastFromAnyType */ -ESX_VI__TEMPLATE__CAST_FROM_ANY_TYPE(HostCpuIdInfo); - -/* esxVI_HostCpuIdInfo_CastListFromAnyType */ -ESX_VI__TEMPLATE__LIST__CAST_FROM_ANY_TYPE(HostCpuIdInfo); - -/* esxVI_HostCpuIdInfo_Deserialize */ -ESX_VI__TEMPLATE__DESERIALIZE(HostCpuIdInfo, -{ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(Int, level); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, vendor); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, eax); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, ebx); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, ecx); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, edx); -}); - -/* esxVI_HostCpuIdInfo_DeserializeList */ -ESX_VI__TEMPLATE__LIST__DESERIALIZE(HostCpuIdInfo); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: SelectionSpec - */ - -/* esxVI_SelectionSpec_Alloc */ -ESX_VI__TEMPLATE__ALLOC(SelectionSpec); - -void -esxVI_SelectionSpec_Free(esxVI_SelectionSpec **selectionSpec) -{ - esxVI_SelectionSpec *local = NULL; - - if (selectionSpec == NULL || *selectionSpec == NULL) { - return; - } - - esxVI_SelectionSpec_Free(&(*selectionSpec)->_next); - - if ((*selectionSpec)->_super != NULL) { - /* - * Explicitly set this pointer to NULL here, otherwise this is will - * result in a dangling pointer. The actual memory of this object is - * freed by a call from the esxVI_TraversalSpec_Free function to the - * esxVI_SelectionSpec_Free function with the base pointer. - * - * Use a local copy of the pointer and set the reference to NULL, - * otherwise Valgrind complains about invalid writes. - */ - local = *selectionSpec; - *selectionSpec = NULL; - - esxVI_TraversalSpec_Free(&local->_super); - } else { - VIR_FREE((*selectionSpec)->name); - - VIR_FREE(*selectionSpec); - } -} - -/* esxVI_SelectionSpec_Validate */ -ESX_VI__TEMPLATE__VALIDATE(SelectionSpec, -{ - if (item->_super != NULL) { - return esxVI_TraversalSpec_Validate(item->_super); - } - - /* All properties are optional */ - (void)type_name; -}); - -/* esxVI_SelectionSpec_AppendToList */ -ESX_VI__TEMPLATE__LIST__APPEND(SelectionSpec); - -int -esxVI_SelectionSpec_Serialize(esxVI_SelectionSpec *selectionSpec, - const char *element, virBufferPtr output) -{ - if (element == NULL || output == NULL) { - ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, "Invalid argument"); - return -1; - } - - if (selectionSpec == NULL) { - return 0; - } - - if (selectionSpec->_super != NULL) { - return esxVI_TraversalSpec_Serialize(selectionSpec->_super, element, - output); - } - - if (esxVI_SelectionSpec_Validate(selectionSpec) < 0) { - return -1; - } - - ESV_VI__XML_TAG__OPEN(output, element, "SelectionSpec"); - - if (esxVI_String_SerializeValue(selectionSpec->name, "name", output) < 0) { - return -1; - } - - ESV_VI__XML_TAG__CLOSE(output, element); - - return 0; -} - -/* esxVI_SelectionSpec_SerializeList */ -ESX_VI__TEMPLATE__LIST__SERIALIZE(SelectionSpec); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: TraversalSpec extends SelectionSpec - */ - -int -esxVI_TraversalSpec_Alloc(esxVI_TraversalSpec **traversalSpec) -{ - if (esxVI_Alloc((void **)traversalSpec, sizeof(esxVI_TraversalSpec)) < 0) { - return -1; - } - - if (esxVI_SelectionSpec_Alloc(&(*traversalSpec)->_base) < 0) { - esxVI_TraversalSpec_Free(traversalSpec); - return -1; - } - - (*traversalSpec)->_base->_super = *traversalSpec; - - return 0; -} - -void -esxVI_TraversalSpec_Free(esxVI_TraversalSpec **traversalSpec) -{ - esxVI_TraversalSpec *local = NULL; - - if (traversalSpec == NULL || *traversalSpec == NULL) { - return; - } - - /* - * Need to store the traversalSpec pointer in a local variable here, - * because it is possible that the traversalSpec pointer and the _super - * pointer represent the same location in memory, e.g. if - * esxVI_SelectionSpec_Free calls esxVI_TraversalSpec_Free with the _super - * pointer as argument. Setting the _super pointer to NULL sets the - * traversalSpec pointer also to NULL, because we're working on a reference - * to this pointer here. - * - * Also use a local copy of the pointer and set the reference to NULL, - * otherwise Valgrind complains about invalid writes. - */ - local = *traversalSpec; - *traversalSpec = NULL; - - /* - * Setting the _super pointer to NULL here is important, otherwise - * esxVI_SelectionSpec_Free would call esxVI_TraversalSpec_Free again, - * resulting in both functions calling each other trying to free the - * _base/_super object until a stackoverflow occurs. - */ - local->_base->_super = NULL; - - esxVI_SelectionSpec_Free(&local->_base); - VIR_FREE(local->type); - VIR_FREE(local->path); - esxVI_SelectionSpec_Free(&local->selectSet); - - VIR_FREE(local); -} - -/* esxVI_TraversalSpec_Validate */ -ESX_VI__TEMPLATE__VALIDATE(TraversalSpec, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(type); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(path); -}); - -/* esxVI_TraversalSpec_Serialize */ -ESX_VI__TEMPLATE__SERIALIZE(TraversalSpec, -{ - if (esxVI_String_SerializeValue(item->_base->name, "name", output) < 0) { - return -1; - } - - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_VALUE(String, type); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_VALUE(String, path); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE(Boolean, skip); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_LIST(SelectionSpec, selectSet); -}); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: ObjectSpec - */ - -/* esxVI_ObjectSpec_Alloc */ -ESX_VI__TEMPLATE__ALLOC(ObjectSpec); - -/* esxVI_ObjectSpec_Free */ -ESX_VI__TEMPLATE__FREE(ObjectSpec, -{ - esxVI_ObjectSpec_Free(&item->_next); - - esxVI_ManagedObjectReference_Free(&item->obj); - esxVI_SelectionSpec_Free(&item->selectSet); -}); - -/* esxVI_ObjectSpec_Validate */ -ESX_VI__TEMPLATE__VALIDATE(ObjectSpec, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(obj); -}); - -/* esxVI_ObjectSpec_AppendToList */ -ESX_VI__TEMPLATE__LIST__APPEND(ObjectSpec); - -/* esxVI_ObjectSpec_Serialize */ -ESX_VI__TEMPLATE__SERIALIZE(ObjectSpec, -{ - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE(ManagedObjectReference, obj); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE(Boolean, skip); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_LIST(SelectionSpec, selectSet); -}); - -/* esxVI_ObjectSpec_SerializeList */ -ESX_VI__TEMPLATE__LIST__SERIALIZE(ObjectSpec); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: PropertyChange - */ - -/* esxVI_PropertyChange_Alloc */ -ESX_VI__TEMPLATE__ALLOC(PropertyChange); - -/* esxVI_PropertyChange_Free */ -ESX_VI__TEMPLATE__FREE(PropertyChange, -{ - esxVI_PropertyChange_Free(&item->_next); - - VIR_FREE(item->name); - esxVI_AnyType_Free(&item->val); -}); - -/* esxVI_PropertyChange_Validate */ -ESX_VI__TEMPLATE__VALIDATE(PropertyChange, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(name); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(op); -}); - -/* esxVI_PropertyChange_AppendToList */ -ESX_VI__TEMPLATE__LIST__APPEND(PropertyChange); - -/* esxVI_PropertyChange_Deserialize */ -ESX_VI__TEMPLATE__DESERIALIZE(PropertyChange, -{ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, name); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(PropertyChangeOp, op); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(AnyType, val); -}); - -/* esxVI_PropertyChange_DeserializeList */ -ESX_VI__TEMPLATE__LIST__DESERIALIZE(PropertyChange); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: PropertySpec - */ - -/* esxVI_PropertySpec_Alloc */ -ESX_VI__TEMPLATE__ALLOC(PropertySpec); - -/* esxVI_PropertySpec_Free */ -ESX_VI__TEMPLATE__FREE(PropertySpec, -{ - esxVI_PropertySpec_Free(&item->_next); - - VIR_FREE(item->type); - esxVI_String_Free(&item->pathSet); -}); - -/* esxVI_PropertySpec_Validate */ -ESX_VI__TEMPLATE__VALIDATE(PropertySpec, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(type); -}); - -/* esxVI_PropertySpec_AppendToList */ -ESX_VI__TEMPLATE__LIST__APPEND(PropertySpec); - -/* esxVI_PropertySpec_Serialize */ -ESX_VI__TEMPLATE__SERIALIZE(PropertySpec, -{ - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_VALUE(String, type); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE(Boolean, all); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_LIST(String, pathSet); -}); - -/* esxVI_PropertySpec_SerializeList */ -ESX_VI__TEMPLATE__LIST__SERIALIZE(PropertySpec); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: PropertyFilterSpec - */ - -/* esxVI_PropertyFilterSpec_Alloc */ -ESX_VI__TEMPLATE__ALLOC(PropertyFilterSpec); - -/* esxVI_PropertyFilterSpec_Free */ -ESX_VI__TEMPLATE__FREE(PropertyFilterSpec, -{ - esxVI_PropertyFilterSpec_Free(&item->_next); - - esxVI_PropertySpec_Free(&item->propSet); - esxVI_ObjectSpec_Free(&item->objectSet); -}); - -/* esxVI_PropertyFilterSpec_Validate */ -ESX_VI__TEMPLATE__VALIDATE(PropertyFilterSpec, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(propSet); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(objectSet); -}); - -/* esxVI_PropertyFilterSpec_AppendToList */ -ESX_VI__TEMPLATE__LIST__APPEND(PropertyFilterSpec); - -/* esxVI_PropertyFilterSpec_Serialize */ -ESX_VI__TEMPLATE__SERIALIZE(PropertyFilterSpec, -{ - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_LIST(PropertySpec, propSet); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_LIST(ObjectSpec, objectSet); -}); - -/* esxVI_PropertyFilterSpec_SerializeList */ -ESX_VI__TEMPLATE__LIST__SERIALIZE(PropertyFilterSpec); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: ObjectContent - */ - -/* esxVI_ObjectContent_Alloc */ -ESX_VI__TEMPLATE__ALLOC(ObjectContent); - -/* esxVI_ObjectContent_Free */ -ESX_VI__TEMPLATE__FREE(ObjectContent, -{ - esxVI_ObjectContent_Free(&item->_next); - - esxVI_ManagedObjectReference_Free(&item->obj); - esxVI_DynamicProperty_Free(&item->propSet); - /*esxVI_MissingProperty_Free(&item->missingSet);*//* FIXME */ -}); - -/* esxVI_ObjectContent_Validate */ -ESX_VI__TEMPLATE__VALIDATE(ObjectContent, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(obj); -}); - -/* esxVI_ObjectContent_AppendToList */ -ESX_VI__TEMPLATE__LIST__APPEND(ObjectContent); - -int -esxVI_ObjectContent_DeepCopy(esxVI_ObjectContent **dest, - esxVI_ObjectContent *src) -{ - if (dest == NULL || *dest != NULL) { - ESX_VI_ERROR(VIR_ERR_INTERNAL_ERROR, "Invalid argument"); - return -1; - } - - if (src == NULL) { - return 0; - } - - if (esxVI_ObjectContent_Alloc(dest) < 0 || - esxVI_ManagedObjectReference_DeepCopy(&(*dest)->obj, src->obj) < 0 || - esxVI_DynamicProperty_DeepCopyList(&(*dest)->propSet, - src->propSet) < 0) { - goto failure; - } - -#if 0 /* FIXME */ - if (esxVI_MissingProperty_DeepCopyList(&(*dest)->missingSet, - src->missingSet) < 0) { - goto failure; - } -#endif - - return 0; - - failure: - esxVI_ObjectContent_Free(dest); - - return -1; -} - -/* esxVI_ObjectContent_Deserialize */ -ESX_VI__TEMPLATE__DESERIALIZE(ObjectContent, -{ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - NULL, obj); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_LIST(DynamicProperty, propSet); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_NOOP(missingSet); /* FIXME */ -}); - -/* esxVI_ObjectContent_DeserializeList */ -ESX_VI__TEMPLATE__LIST__DESERIALIZE(ObjectContent); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: ObjectUpdate - */ - -/* esxVI_ObjectUpdate_Alloc */ -ESX_VI__TEMPLATE__ALLOC(ObjectUpdate); - -/* esxVI_ObjectUpdate_Free */ -ESX_VI__TEMPLATE__FREE(ObjectUpdate, -{ - esxVI_ObjectUpdate_Free(&item->_next); - - esxVI_ManagedObjectReference_Free(&item->obj); - esxVI_PropertyChange_Free(&item->changeSet); - /*esxVI_MissingProperty_Free(&item->missingSet);*//* FIXME */ -}); - -/* esxVI_ObjectUpdate_Validate */ -ESX_VI__TEMPLATE__VALIDATE(ObjectUpdate, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(kind); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(obj); -}); - -/* esxVI_ObjectUpdate_AppendToList */ -ESX_VI__TEMPLATE__LIST__APPEND(ObjectUpdate); - -/* esxVI_ObjectUpdate_Deserialize */ -ESX_VI__TEMPLATE__DESERIALIZE(ObjectUpdate, -{ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(ObjectUpdateKind, kind); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - NULL, obj); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_LIST(PropertyChange, changeSet); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_NOOP(missingSet); /* FIXME */ -}); - -/* esxVI_ObjectUpdate_DeserializeList */ -ESX_VI__TEMPLATE__LIST__DESERIALIZE(ObjectUpdate); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: PropertyFilterUpdate - */ - -/* esxVI_PropertyFilterUpdate_Alloc */ -ESX_VI__TEMPLATE__ALLOC(PropertyFilterUpdate); - -/* esxVI_PropertyFilterUpdate_Free */ -ESX_VI__TEMPLATE__FREE(PropertyFilterUpdate, -{ - esxVI_PropertyFilterUpdate_Free(&item->_next); - - esxVI_ManagedObjectReference_Free(&item->filter); - esxVI_ObjectUpdate_Free(&item->objectSet); - /*esxVI_MissingProperty_Free(&item->missingSet);*//* FIXME */ -}); - -/* esxVI_PropertyFilterUpdate_Validate */ -ESX_VI__TEMPLATE__VALIDATE(PropertyFilterUpdate, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(filter); -}); - -/* esxVI_PropertyFilterUpdate_AppendToList */ -ESX_VI__TEMPLATE__LIST__APPEND(PropertyFilterUpdate); - -/* esxVI_PropertyFilterUpdate_Deserialize */ -ESX_VI__TEMPLATE__DESERIALIZE(PropertyFilterUpdate, -{ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - NULL, filter); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_LIST(ObjectUpdate, objectSet); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_NOOP(missingSet); /* FIXME */ -}); - -/* esxVI_PropertyFilterUpdate_DeserializeList */ -ESX_VI__TEMPLATE__LIST__DESERIALIZE(PropertyFilterUpdate); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: AboutInfo - */ - -/* esxVI_AboutInfo_Alloc */ -ESX_VI__TEMPLATE__ALLOC(AboutInfo); - -/* esxVI_AboutInfo_Free */ -ESX_VI__TEMPLATE__FREE(AboutInfo, -{ - VIR_FREE(item->name); - VIR_FREE(item->fullName); - VIR_FREE(item->vendor); - VIR_FREE(item->version); - VIR_FREE(item->build); - VIR_FREE(item->localeVersion); - VIR_FREE(item->localeBuild); - VIR_FREE(item->osType); - VIR_FREE(item->productLineId); - VIR_FREE(item->apiType); - VIR_FREE(item->apiVersion); -}); - -/* esxVI_AboutInfo_Validate */ -ESX_VI__TEMPLATE__VALIDATE(AboutInfo, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(name); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(fullName); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(vendor); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(version); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(build); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(localeVersion); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(localeBuild); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(osType); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(productLineId); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(apiType); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(apiVersion); -}); - -/* esxVI_AboutInfo_Deserialize */ -ESX_VI__TEMPLATE__DESERIALIZE(AboutInfo, -{ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, name); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, fullName); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, vendor); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, version); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, build); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, localeVersion); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, localeBuild); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, osType); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, productLineId); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, apiType); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, apiVersion); -}); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: ServiceContent - */ - -/* esxVI_ServiceContent_Alloc */ -ESX_VI__TEMPLATE__ALLOC(ServiceContent); - -/* esxVI_ServiceContent_Free */ -ESX_VI__TEMPLATE__FREE(ServiceContent, -{ - esxVI_ManagedObjectReference_Free(&item->rootFolder); - esxVI_ManagedObjectReference_Free(&item->propertyCollector); - esxVI_ManagedObjectReference_Free(&item->viewManager); - esxVI_AboutInfo_Free(&item->about); - esxVI_ManagedObjectReference_Free(&item->setting); - esxVI_ManagedObjectReference_Free(&item->userDirectory); - esxVI_ManagedObjectReference_Free(&item->sessionManager); - esxVI_ManagedObjectReference_Free(&item->authorizationManager); - esxVI_ManagedObjectReference_Free(&item->perfManager); - esxVI_ManagedObjectReference_Free(&item->scheduledTaskManager); - esxVI_ManagedObjectReference_Free(&item->alarmManager); - esxVI_ManagedObjectReference_Free(&item->eventManager); - esxVI_ManagedObjectReference_Free(&item->taskManager); - esxVI_ManagedObjectReference_Free(&item->extensionManager); - esxVI_ManagedObjectReference_Free(&item->customizationSpecManager); - esxVI_ManagedObjectReference_Free(&item->customFieldsManager); - esxVI_ManagedObjectReference_Free(&item->accountManager); - esxVI_ManagedObjectReference_Free(&item->diagnosticManager); - esxVI_ManagedObjectReference_Free(&item->licenseManager); - esxVI_ManagedObjectReference_Free(&item->searchIndex); - esxVI_ManagedObjectReference_Free(&item->fileManager); - esxVI_ManagedObjectReference_Free(&item->virtualDiskManager); - esxVI_ManagedObjectReference_Free(&item->virtualizationManager); -}); - -/* esxVI_ServiceContent_Validate */ -ESX_VI__TEMPLATE__VALIDATE(ServiceContent, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(rootFolder); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(propertyCollector); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(about); -}); - -/* esxVI_ServiceContent_Deserialize */ -ESX_VI__TEMPLATE__DESERIALIZE(ServiceContent, -{ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - "Folder", rootFolder); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - "PropertyCollector", - propertyCollector); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - "ViewManager", - viewManager); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(AboutInfo, about); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - "OptionManager", setting); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - "UserDirectory", - userDirectory); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - "SessionManager", - sessionManager); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - "AuthorizationManager", - authorizationManager); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - "PerformanceManager", - perfManager); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - "ScheduledTaskManager", - scheduledTaskManager); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - "AlarmManager", - alarmManager); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - "EventManager", - eventManager); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - "TaskManager", - taskManager); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - "ExtensionManager", - extensionManager); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - "CustomizationSpecManager", - customizationSpecManager); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - "CustomFieldsManager", - customFieldsManager); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - "HostLocalAccountManager", - accountManager); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - "DiagnosticManager", - diagnosticManager); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - "LicenseManager", - licenseManager); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - "SearchIndex", - searchIndex); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - "FileManager", - fileManager); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - "VirtualDiskManager", - virtualDiskManager); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - "VirtualizationManager", - virtualizationManager); -}); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: UpdateSet - */ - -/* esxVI_UpdateSet_Alloc */ -ESX_VI__TEMPLATE__ALLOC(UpdateSet); - -/* esxVI_UpdateSet_Free */ -ESX_VI__TEMPLATE__FREE(UpdateSet, -{ - VIR_FREE(item->version); - esxVI_PropertyFilterUpdate_Free(&item->filterSet); -}); - -/* esxVI_UpdateSet_Validate */ -ESX_VI__TEMPLATE__VALIDATE(UpdateSet, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(version); -}); - -/* esxVI_UpdateSet_Deserialize */ -ESX_VI__TEMPLATE__DESERIALIZE(UpdateSet, -{ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, version); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_LIST(PropertyFilterUpdate, - filterSet); -}); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: SharesInfo - */ - -/* esxVI_SharesInfo_Alloc */ -ESX_VI__TEMPLATE__ALLOC(SharesInfo); - -/* esxVI_SharesInfo_Free */ -ESX_VI__TEMPLATE__FREE(SharesInfo, -{ - esxVI_Int_Free(&item->shares); -}); - -/* esxVI_SharesInfo_Validate */ -ESX_VI__TEMPLATE__VALIDATE(SharesInfo, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(shares); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(level); -}); - -/* esxVI_SharesInfo_CastFromAnyType */ -ESX_VI__TEMPLATE__CAST_FROM_ANY_TYPE(SharesInfo); - -/* esxVI_SharesInfo_Deserialize */ -ESX_VI__TEMPLATE__DESERIALIZE(SharesInfo, -{ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(Int, shares); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(SharesLevel, level); -}); - -/* esxVI_SharesInfo_Serialize */ -ESX_VI__TEMPLATE__SERIALIZE(SharesInfo, -{ - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE(Int, shares); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE(SharesLevel, level); -}); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: ResourceAllocationInfo - */ - -/* esxVI_ResourceAllocationInfo_Alloc */ -ESX_VI__TEMPLATE__ALLOC(ResourceAllocationInfo); - -/* esxVI_ResourceAllocationInfo_Free */ -ESX_VI__TEMPLATE__FREE(ResourceAllocationInfo, -{ - esxVI_Long_Free(&item->reservation); - esxVI_Long_Free(&item->limit); - esxVI_SharesInfo_Free(&item->shares); - esxVI_Long_Free(&item->overheadLimit); -}); - -/* esxVI_ResourceAllocationInfo_Validate */ -ESX_VI__TEMPLATE__VALIDATE_NOOP(ResourceAllocationInfo); - -/* esxVI_ResourceAllocationInfo_Serialize */ -ESX_VI__TEMPLATE__SERIALIZE(ResourceAllocationInfo, -{ - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE(Long, reservation); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE(Boolean, expandableReservation); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE(Long, limit); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE(SharesInfo, shares); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE(Long, overheadLimit); -}); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: ResourcePoolResourceUsage - */ - -/* esxVI_ResourcePoolResourceUsage_Alloc */ -ESX_VI__TEMPLATE__ALLOC(ResourcePoolResourceUsage); - -/* esxVI_ResourcePoolResourceUsage_Free */ -ESX_VI__TEMPLATE__FREE(ResourcePoolResourceUsage, -{ - esxVI_Long_Free(&item->reservationUsed); - esxVI_Long_Free(&item->reservationUsedForVm); - esxVI_Long_Free(&item->unreservedForPool); - esxVI_Long_Free(&item->unreservedForVm); - esxVI_Long_Free(&item->overallUsage); - esxVI_Long_Free(&item->maxUsage); -}); - -/* esxVI_ResourcePoolResourceUsage_Validate */ -ESX_VI__TEMPLATE__VALIDATE(ResourcePoolResourceUsage, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(reservationUsed); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(reservationUsedForVm); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(unreservedForPool); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(unreservedForVm); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(overallUsage); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(maxUsage); -}); - -/* esxVI_ResourcePoolResourceUsage_CastFromAnyType */ -ESX_VI__TEMPLATE__CAST_FROM_ANY_TYPE(ResourcePoolResourceUsage); - -/* esxVI_ResourcePoolResourceUsage_Deserialize */ -ESX_VI__TEMPLATE__DESERIALIZE(ResourcePoolResourceUsage, -{ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(Long, reservationUsed); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(Long, reservationUsedForVm); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(Long, unreservedForPool); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(Long, unreservedForVm); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(Long, overallUsage); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(Long, maxUsage); -}); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: VirtualMachineConfigSpec - */ - -/* esxVI_VirtualMachineConfigSpec_Alloc */ -ESX_VI__TEMPLATE__ALLOC(VirtualMachineConfigSpec); - -/* esxVI_VirtualMachineConfigSpec_Free */ -ESX_VI__TEMPLATE__FREE(VirtualMachineConfigSpec, -{ - VIR_FREE(item->changeVersion); - VIR_FREE(item->name); - VIR_FREE(item->version); - VIR_FREE(item->uuid); - esxVI_Long_Free(&item->npivNodeWorldWideName); - esxVI_Long_Free(&item->npivPortWorldWideName); - VIR_FREE(item->npivWorldWideNameType); - VIR_FREE(item->npivWorldWideNameOp); - VIR_FREE(item->locationId); - VIR_FREE(item->guestId); - VIR_FREE(item->alternateGuestName); - VIR_FREE(item->annotation); - /* FIXME: implement missing */ - esxVI_Int_Free(&item->numCPUs); - esxVI_Long_Free(&item->memoryMB); - /* FIXME: implement missing */ - esxVI_ResourceAllocationInfo_Free(&item->cpuAllocation); - esxVI_ResourceAllocationInfo_Free(&item->memoryAllocation); - /* FIXME: implement missing */ - VIR_FREE(item->swapPlacement); - /* FIXME: implement missing */ -}); - -/* esxVI_VirtualMachineConfigSpec_Validate */ -ESX_VI__TEMPLATE__VALIDATE_NOOP(VirtualMachineConfigSpec); - -/* esxVI_VirtualMachineConfigSpec_Serialize */ -ESX_VI__TEMPLATE__SERIALIZE(VirtualMachineConfigSpec, -{ - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_VALUE(String, changeVersion); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_VALUE(String, name); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_VALUE(String, version); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_VALUE(String, uuid); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_LIST(Long, npivNodeWorldWideName); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_LIST(Long, npivPortWorldWideName); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_VALUE(String, npivWorldWideNameType); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_VALUE(String, npivWorldWideNameOp); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_VALUE(String, locationId); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_VALUE(String, guestId); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_VALUE(String, alternateGuestName); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_VALUE(String, annotation); - /* FIXME: implement missing */ - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE(Int, numCPUs); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE(Long, memoryMB); - /* FIXME: implement missing */ - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE(ResourceAllocationInfo, - cpuAllocation); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE(ResourceAllocationInfo, - memoryAllocation); - /* FIXME: implement missing */ - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_VALUE(String, swapPlacement); - /* FIXME: implement missing */ -}); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: Event - */ - -/* esxVI_Event_Alloc */ -ESX_VI__TEMPLATE__ALLOC(Event); - -/* esxVI_Event_Free */ -ESX_VI__TEMPLATE__FREE(Event, -{ - esxVI_Event_Free(&item->_next); - - /* FIXME: implement the rest */ - esxVI_Int_Free(&item->key); - esxVI_Int_Free(&item->chainId); - esxVI_DateTime_Free(&item->createdTime); - VIR_FREE(item->userName); - VIR_FREE(item->fullFormattedMessage); -}); - -/* esxVI_Event_Validate */ -ESX_VI__TEMPLATE__VALIDATE(Event, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(key); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(chainId); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(createdTime); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(userName); -}); - -/* esxVI_Event_Deserialize */ -ESX_VI__TEMPLATE__DESERIALIZE(Event, -{ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(Int, key); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(Int, chainId); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(DateTime, createdTime); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, userName); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_NOOP(datacenter); /* FIXME */ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_NOOP(computeResource); /* FIXME */ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_NOOP(host); /* FIXME */ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_NOOP(vm); /* FIXME */ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, fullFormattedMessage); -}); - -/* esxVI_Event_DeserializeList */ -ESX_VI__TEMPLATE__LIST__DESERIALIZE(Event); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: UserSession - */ - -/* esxVI_UserSession_Alloc */ -ESX_VI__TEMPLATE__ALLOC(UserSession); - -/* esxVI_UserSession_Free */ -ESX_VI__TEMPLATE__FREE(UserSession, -{ - VIR_FREE(item->key); - VIR_FREE(item->userName); - VIR_FREE(item->fullName); - esxVI_DateTime_Free(&item->loginTime); - esxVI_DateTime_Free(&item->lastActiveTime); - VIR_FREE(item->locale); - VIR_FREE(item->messageLocale); -}); - -/* esxVI_UserSession_Validate */ -ESX_VI__TEMPLATE__VALIDATE(UserSession, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(key); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(userName); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(fullName); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(loginTime); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(lastActiveTime); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(locale); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(messageLocale); -}); - -/* esxVI_UserSession_CastFromAnyType */ -ESX_VI__TEMPLATE__CAST_FROM_ANY_TYPE(UserSession); - -/* esxVI_UserSession_Deserialize */ -ESX_VI__TEMPLATE__DESERIALIZE(UserSession, -{ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, key); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, userName); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, fullName); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(DateTime, loginTime); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(DateTime, lastActiveTime); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, locale); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, messageLocale); -}); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: VirtualMachineQuestionInfo - */ - -/* esxVI_VirtualMachineQuestionInfo_Alloc */ -ESX_VI__TEMPLATE__ALLOC(VirtualMachineQuestionInfo); - -/* esxVI_VirtualMachineQuestionInfo_Free */ -ESX_VI__TEMPLATE__FREE(VirtualMachineQuestionInfo, -{ - VIR_FREE(item->id); - VIR_FREE(item->text); - esxVI_ChoiceOption_Free(&item->choice); - /*esxVI_VirtualMachineMessage_Free(&item->message);*//* FIXME */ -}); - -/* esxVI_VirtualMachineQuestionInfo_Validate */ -ESX_VI__TEMPLATE__VALIDATE(VirtualMachineQuestionInfo, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(id); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(text); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(choice); -}); - -/* esxVI_VirtualMachineQuestionInfo_CastFromAnyType */ -ESX_VI__TEMPLATE__CAST_FROM_ANY_TYPE(VirtualMachineQuestionInfo); - -/* esxVI_VirtualMachineQuestionInfo_Deserialize */ -ESX_VI__TEMPLATE__DESERIALIZE(VirtualMachineQuestionInfo, -{ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, id); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, text); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(ChoiceOption, choice); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_NOOP(message); /* FIXME */ -}); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: ElementDescription extends Description - * - * In contrast to SelectionSpec and TraversalSpec just merge - * Description into ElementDescription for simplicity, because - * only ElementDescription is used. - */ - -/* esxVI_ElementDescription_Alloc */ -ESX_VI__TEMPLATE__ALLOC(ElementDescription); - -/* esxVI_ElementDescription_Free */ -ESX_VI__TEMPLATE__FREE(ElementDescription, -{ - esxVI_ElementDescription_Free(&item->_next); - - VIR_FREE(item->label); - VIR_FREE(item->summary); - VIR_FREE(item->key); -}); - -/* esxVI_ElementDescription_Validate */ -ESX_VI__TEMPLATE__VALIDATE(ElementDescription, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(label); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(summary); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(key); -}); - -/* esxVI_ElementDescription_AppendToList */ -ESX_VI__TEMPLATE__LIST__APPEND(ElementDescription); - -/* esxVI_ElementDescription_Deserialize */ -ESX_VI__TEMPLATE__DESERIALIZE(ElementDescription, -{ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, label); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, summary); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, key); -}); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: ChoiceOption extends OptionType - * - * In contrast to SelectionSpec and TraversalSpec just merge - * OptionType into ChoiceOption for simplicity, because - * only ChoiceOption is used. - */ - -/* esxVI_ChoiceOption_Alloc */ -ESX_VI__TEMPLATE__ALLOC(ChoiceOption); - -/* esxVI_ChoiceOption_Free */ -ESX_VI__TEMPLATE__FREE(ChoiceOption, -{ - esxVI_ElementDescription_Free(&item->choiceInfo); - esxVI_Int_Free(&item->defaultIndex); -}); - -/* esxVI_ChoiceOption_Validate */ -ESX_VI__TEMPLATE__VALIDATE(ChoiceOption, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(choiceInfo); -}); - -/* esxVI_ChoiceOption_Deserialize */ -ESX_VI__TEMPLATE__DESERIALIZE(ChoiceOption, -{ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(Boolean, valueIsReadonly); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_LIST(ElementDescription, choiceInfo); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(Int, defaultIndex); -}); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: PerfMetricId - */ - -/* esxVI_PerfMetricId_Alloc */ -ESX_VI__TEMPLATE__ALLOC(PerfMetricId); - -/* esxVI_PerfMetricId_Free */ -ESX_VI__TEMPLATE__FREE(PerfMetricId, -{ - esxVI_PerfMetricId_Free(&item->_next); - - esxVI_Int_Free(&item->counterId); - VIR_FREE(item->instance); -}); - -/* esxVI_PerfMetricId_Validate */ -ESX_VI__TEMPLATE__VALIDATE(PerfMetricId, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(counterId); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(instance); -}); - -/* esxVI_PerfMetricId_Serialize */ -ESX_VI__TEMPLATE__SERIALIZE(PerfMetricId, -{ - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE(Int, counterId); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_VALUE(String, instance); -}); - -/* esxVI_PerfMetricId_SerializeList */ -ESX_VI__TEMPLATE__LIST__SERIALIZE(PerfMetricId); - -/* esxVI_PerfMetricId_Deserialize */ -ESX_VI__TEMPLATE__DESERIALIZE(PerfMetricId, -{ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(Int, counterId); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, instance); -}); - -/* esxVI_PerfMetricId_DeserializeList */ -ESX_VI__TEMPLATE__LIST__DESERIALIZE(PerfMetricId); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: PerfCounterInfo - */ - -/* esxVI_PerfCounterInfo_Alloc */ -ESX_VI__TEMPLATE__ALLOC(PerfCounterInfo); - -/* esxVI_PerfCounterInfo_Free */ -ESX_VI__TEMPLATE__FREE(PerfCounterInfo, -{ - esxVI_PerfCounterInfo_Free(&item->_next); - - esxVI_Int_Free(&item->key); - esxVI_ElementDescription_Free(&item->nameInfo); - esxVI_ElementDescription_Free(&item->groupInfo); - esxVI_ElementDescription_Free(&item->unitInfo); - esxVI_Int_Free(&item->level); - esxVI_Int_Free(&item->associatedCounterId); -}); - -/* esxVI_PerfCounterInfo_Validate */ -ESX_VI__TEMPLATE__VALIDATE(PerfCounterInfo, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(key); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(nameInfo); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(groupInfo); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(unitInfo); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(rollupType); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(statsType); -}); - -/* esxVI_PerfCounterInfo_Deserialize */ -ESX_VI__TEMPLATE__DESERIALIZE(PerfCounterInfo, -{ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(Int, key); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(ElementDescription, nameInfo); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(ElementDescription, groupInfo); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(ElementDescription, unitInfo); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(PerfSummaryType, rollupType); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(PerfStatsType, statsType); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(Int, level); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_LIST(Int, associatedCounterId); -}); - -/* esxVI_PerfCounterInfo_DeserializeList */ -ESX_VI__TEMPLATE__LIST__DESERIALIZE(PerfCounterInfo); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: PerfQuerySpec - */ - -/* esxVI_PerfQuerySpec_Alloc */ -ESX_VI__TEMPLATE__ALLOC(PerfQuerySpec); - -/* esxVI_PerfQuerySpec_Free */ -ESX_VI__TEMPLATE__FREE(PerfQuerySpec, -{ - esxVI_PerfQuerySpec_Free(&item->_next); - - esxVI_ManagedObjectReference_Free(&item->entity); - esxVI_DateTime_Free(&item->startTime); - esxVI_DateTime_Free(&item->endTime); - esxVI_Int_Free(&item->maxSample); - esxVI_PerfMetricId_Free(&item->metricId); - esxVI_Int_Free(&item->intervalId); - VIR_FREE(item->format); -}); - -/* esxVI_PerfQuerySpec_Validate */ -ESX_VI__TEMPLATE__VALIDATE(PerfQuerySpec, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(entity); -}); - -/* esxVI_PerfQuerySpec_Serialize */ -ESX_VI__TEMPLATE__SERIALIZE(PerfQuerySpec, -{ - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE(ManagedObjectReference, entity); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE(DateTime, startTime); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE(DateTime, endTime); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE(Int, maxSample); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_LIST(PerfMetricId, metricId); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE(Int, intervalId); - ESX_VI__TEMPLATE__PROPERTY__SERIALIZE_VALUE(String, format); -}); - -/* esxVI_PerfQuerySpec_SerializeList */ -ESX_VI__TEMPLATE__LIST__SERIALIZE(PerfQuerySpec); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: PerfSampleInfo - */ - -/* esxVI_PerfSampleInfo_Alloc */ -ESX_VI__TEMPLATE__ALLOC(PerfSampleInfo); - -/* esxVI_PerfSampleInfo_Free */ -ESX_VI__TEMPLATE__FREE(PerfSampleInfo, -{ - esxVI_PerfSampleInfo_Free(&item->_next); - - esxVI_DateTime_Free(&item->timestamp); - esxVI_Int_Free(&item->interval); -}); - -/* esxVI_PerfSampleInfo_Validate */ -ESX_VI__TEMPLATE__VALIDATE(PerfSampleInfo, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(timestamp); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(interval); -}); - -/* esxVI_PerfSampleInfo_AppendToList */ -ESX_VI__TEMPLATE__LIST__APPEND(PerfSampleInfo); - -/* esxVI_PerfSampleInfo_Deserialize */ -ESX_VI__TEMPLATE__DESERIALIZE(PerfSampleInfo, -{ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(DateTime, timestamp); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(Int, interval); -}); - -/* esxVI_PerfSampleInfo_DeserializeList */ -ESX_VI__TEMPLATE__LIST__DESERIALIZE(PerfSampleInfo); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: PerfMetricIntSeries extends PerfMetricSeries - * - * In contrast to SelectionSpec and TraversalSpec just merge - * PerfMetricSeries into PerfMetricIntSeries for simplicity, because - * only PerfMetricIntSeries is used and the other type inheriting - * PerfMetricSeries (PerfMetricSeriesCSV) is not used. - */ - -/* esxVI_PerfMetricIntSeries_Alloc */ -ESX_VI__TEMPLATE__ALLOC(PerfMetricIntSeries); - -/* esxVI_PerfMetricIntSeries_Free */ -ESX_VI__TEMPLATE__FREE(PerfMetricIntSeries, -{ - esxVI_PerfMetricIntSeries_Free(&item->_next); - - esxVI_PerfMetricId_Free(&item->id); - esxVI_Long_Free(&item->value); -}); - -/* esxVI_PerfMetricIntSeries_Validate */ -ESX_VI__TEMPLATE__VALIDATE(PerfMetricIntSeries, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(id); -}); - -/* esxVI_PerfMetricIntSeries_AppendToList */ -ESX_VI__TEMPLATE__LIST__APPEND(PerfMetricIntSeries); - -/* esxVI_PerfMetricIntSeries_Deserialize */ -ESX_VI__TEMPLATE__DESERIALIZE(PerfMetricIntSeries, -{ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(PerfMetricId, id); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_LIST(Long, value); -}); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: PerfEntityMetric extends PerfEntityMetricBase - * - * In contrast to SelectionSpec and TraversalSpec just merge - * PerfEntityMetricBase into PerfEntityMetric for simplicity, because - * only PerfEntityMetric is used and the other type inheriting - * PerfEntityMetric (PerfEntityMetricCSV) is not used. - * - * Also use PerfMetricIntSeries instead of the correct base type - * PerfMetricSeries for the value property, because only - * PerfMetricIntSeries is used. - */ - -/* esxVI_PerfEntityMetric_Alloc */ -ESX_VI__TEMPLATE__ALLOC(PerfEntityMetric); - -/* esxVI_PerfEntityMetric_Free */ -ESX_VI__TEMPLATE__FREE(PerfEntityMetric, -{ - esxVI_PerfEntityMetric_Free(&item->_next); - - esxVI_ManagedObjectReference_Free(&item->entity); - esxVI_PerfSampleInfo_Free(&item->sampleInfo); - esxVI_PerfMetricIntSeries_Free(&item->value); -}); - -/* esxVI_PerfEntityMetric_Validate */ -ESX_VI__TEMPLATE__VALIDATE(PerfEntityMetric, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(entity); -}); - -/* esxVI_PerfEntityMetric_Deserialize */ -ESX_VI__TEMPLATE__DESERIALIZE(PerfEntityMetric, -{ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - NULL, entity); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_LIST(PerfSampleInfo, sampleInfo); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_LIST(PerfMetricIntSeries, value); -}); - -/* esxVI_PerfEntityMetric_DeserializeList */ -ESX_VI__TEMPLATE__LIST__DESERIALIZE(PerfEntityMetric); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: TaskInfo - */ - -/* esxVI_TaskInfo_Alloc */ -ESX_VI__TEMPLATE__ALLOC(TaskInfo); - -/* esxVI_TaskInfo_Free */ -ESX_VI__TEMPLATE__FREE(TaskInfo, -{ - esxVI_TaskInfo_Free(&item->_next); - - VIR_FREE(item->key); - esxVI_ManagedObjectReference_Free(&item->task); - VIR_FREE(item->name); - VIR_FREE(item->descriptionId); - esxVI_ManagedObjectReference_Free(&item->entity); - VIR_FREE(item->entityName); - /*esxVI_ManagedObjectReference_Free(&item->locked);*//* FIXME */ - /*esxVI_MethodFault_Free(&item->error);*//* FIXME */ - esxVI_AnyType_Free(&item->result); - esxVI_Int_Free(&item->progress); - /*esxVI_TaskReason_Free(&item->reason);*//* FIXME */ - esxVI_DateTime_Free(&item->queueTime); - esxVI_DateTime_Free(&item->startTime); - esxVI_DateTime_Free(&item->completeTime); - esxVI_Int_Free(&item->eventChainId); -}); - -/* esxVI_TaskInfo_Validate */ -ESX_VI__TEMPLATE__VALIDATE(TaskInfo, -{ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(key); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(task); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(descriptionId); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(state); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(cancelled); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(cancelable); - /*ESX_VI__TEMPLATE__PROPERTY__REQUIRE(reason);*//* FIXME */ - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(queueTime); - ESX_VI__TEMPLATE__PROPERTY__REQUIRE(eventChainId); -}); - -/* esxVI_TaskInfo_CastFromAnyType */ -ESX_VI__TEMPLATE__CAST_FROM_ANY_TYPE(TaskInfo); - -/* esxVI_TaskInfo_AppendToList */ -ESX_VI__TEMPLATE__LIST__APPEND(TaskInfo); - -/* esxVI_TaskInfo_Deserialize */ -ESX_VI__TEMPLATE__DESERIALIZE(TaskInfo, -{ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, key); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - "Task", task); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, name); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, descriptionId); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_EXPECTED(ManagedObjectReference, - NULL, entity); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_VALUE(String, entityName); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_NOOP(locked); /* FIXME */ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(TaskInfoState, state); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(Boolean, cancelled); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(Boolean, cancelable); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_NOOP(error); /* FIXME */ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(AnyType, result); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(Int, progress); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE_NOOP(reason); /* FIXME */ - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(DateTime, queueTime); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(DateTime, startTime); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(DateTime, completeTime); - ESX_VI__TEMPLATE__PROPERTY__DESERIALIZE(Int, eventChainId); -}); +#include "esx_vi_types.generated.c" diff --git a/src/esx/esx_vi_types.h b/src/esx/esx_vi_types.h index e5451e9..a61cdc1 100644 --- a/src/esx/esx_vi_types.h +++ b/src/esx/esx_vi_types.h @@ -25,13 +25,8 @@ # include "buf.h" - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * XSI - */ - typedef enum _esxVI_Type esxVI_Type; +typedef struct _esxVI_Object esxVI_Object; @@ -49,75 +44,50 @@ typedef struct _esxVI_DateTime esxVI_DateTime; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Enums - */ - -typedef enum _esxVI_ManagedEntityStatus esxVI_ManagedEntityStatus; -typedef enum _esxVI_ObjectUpdateKind esxVI_ObjectUpdateKind; -typedef enum _esxVI_PerfSummaryType esxVI_PerfSummaryType; -typedef enum _esxVI_PerfStatsType esxVI_PerfStatsType; -typedef enum _esxVI_PropertyChangeOp esxVI_PropertyChangeOp; -typedef enum _esxVI_SharesLevel esxVI_SharesLevel; -typedef enum _esxVI_TaskInfoState esxVI_TaskInfoState; -typedef enum _esxVI_VirtualMachineMovePriority esxVI_VirtualMachineMovePriority; -typedef enum _esxVI_VirtualMachinePowerState esxVI_VirtualMachinePowerState; - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * VI Types */ typedef struct _esxVI_Fault esxVI_Fault; typedef struct _esxVI_ManagedObjectReference esxVI_ManagedObjectReference; -typedef struct _esxVI_DynamicProperty esxVI_DynamicProperty; -typedef struct _esxVI_HostCpuIdInfo esxVI_HostCpuIdInfo; -typedef struct _esxVI_SelectionSpec esxVI_SelectionSpec; -typedef struct _esxVI_TraversalSpec esxVI_TraversalSpec; -typedef struct _esxVI_ObjectSpec esxVI_ObjectSpec; -typedef struct _esxVI_PropertyChange esxVI_PropertyChange; -typedef struct _esxVI_PropertySpec esxVI_PropertySpec; -typedef struct _esxVI_PropertyFilterSpec esxVI_PropertyFilterSpec; -typedef struct _esxVI_ObjectContent esxVI_ObjectContent; -typedef struct _esxVI_ObjectUpdate esxVI_ObjectUpdate; -typedef struct _esxVI_PropertyFilterUpdate esxVI_PropertyFilterUpdate; -typedef struct _esxVI_AboutInfo esxVI_AboutInfo; -typedef struct _esxVI_ServiceContent esxVI_ServiceContent; -typedef struct _esxVI_UpdateSet esxVI_UpdateSet; -typedef struct _esxVI_SharesInfo esxVI_SharesInfo; -typedef struct _esxVI_ResourceAllocationInfo esxVI_ResourceAllocationInfo; -typedef struct _esxVI_ResourcePoolResourceUsage esxVI_ResourcePoolResourceUsage; -typedef struct _esxVI_VirtualMachineConfigSpec esxVI_VirtualMachineConfigSpec; -typedef struct _esxVI_Event esxVI_Event; -typedef struct _esxVI_UserSession esxVI_UserSession; -typedef struct _esxVI_VirtualMachineQuestionInfo esxVI_VirtualMachineQuestionInfo; -typedef struct _esxVI_ElementDescription esxVI_ElementDescription; -typedef struct _esxVI_ChoiceOption esxVI_ChoiceOption; -typedef struct _esxVI_PerfMetricId esxVI_PerfMetricId; -typedef struct _esxVI_PerfCounterInfo esxVI_PerfCounterInfo; -typedef struct _esxVI_PerfQuerySpec esxVI_PerfQuerySpec; -typedef struct _esxVI_PerfSampleInfo esxVI_PerfSampleInfo; -typedef struct _esxVI_PerfMetricIntSeries esxVI_PerfMetricIntSeries; -typedef struct _esxVI_PerfEntityMetric esxVI_PerfEntityMetric; -typedef struct _esxVI_TaskInfo esxVI_TaskInfo; + +#include "esx_vi_types.generated.typedef" /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * XSI: Type + * Type */ enum _esxVI_Type { esxVI_Type_Undefined = 0, esxVI_Type_Boolean, + esxVI_Type_AnyType, esxVI_Type_String, esxVI_Type_Short, esxVI_Type_Int, esxVI_Type_Long, + esxVI_Type_DateTime, + esxVI_Type_Fault, + esxVI_Type_ManagedObjectReference, + +#include "esx_vi_types.generated.typeenum" + esxVI_Type_Other, }; -const char *esxVI_Type_Name(esxVI_Type type); +const char *esxVI_Type_ToString(esxVI_Type type); +esxVI_Type esxVI_Type_FromString(const char *type); + + + +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * Object extends List + */ + +struct _esxVI_Object { + esxVI_Object *_next; /* optional */ + esxVI_Type _type; /* required */ +}; @@ -142,8 +112,10 @@ int esxVI_Boolean_Deserialize(xmlNodePtr node, esxVI_Boolean *boolean_); */ struct _esxVI_AnyType { - xmlNodePtr _node; /* required */ + esxVI_AnyType *_unused; /* optional */ + esxVI_Type _type; /* = esxVI_Type_AnyType */ /* required */ + xmlNodePtr node; /* required */ esxVI_Type type; /* required */ char *other; /* required */ char *value; /* required */ @@ -170,12 +142,14 @@ int esxVI_AnyType_Deserialize(xmlNodePtr node, esxVI_AnyType **anyType); struct _esxVI_String { esxVI_String *_next; /* optional */ + esxVI_Type _type; /* required */ char *value; /* required */ }; int esxVI_String_Alloc(esxVI_String **string); void esxVI_String_Free(esxVI_String **stringList); +int esxVI_String_Validate(esxVI_String *string); int esxVI_String_AppendToList(esxVI_String **stringList, esxVI_String *string); int esxVI_String_AppendValueToList(esxVI_String **stringList, const char *value); @@ -202,6 +176,7 @@ int esxVI_String_DeserializeValue(xmlNodePtr node, char **value); struct _esxVI_Int { esxVI_Int *_next; /* optional */ + esxVI_Type _type; /* required */ int32_t value; /* required */ }; @@ -225,6 +200,7 @@ int esxVI_Int_Deserialize(xmlNodePtr node, esxVI_Int **number); struct _esxVI_Long { esxVI_Long *_next; /* optional */ + esxVI_Type _type; /* required */ int64_t value; /* required */ }; @@ -246,6 +222,9 @@ int esxVI_Long_Deserialize(xmlNodePtr node, esxVI_Long **number); */ struct _esxVI_DateTime { + esxVI_DateTime *_unused; /* optional */ + esxVI_Type _type; /* required */ + char *value; /* required */ }; @@ -259,170 +238,13 @@ int esxVI_DateTime_Deserialize(xmlNodePtr node, esxVI_DateTime **dateTime); /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Enum: ManagedEntityStatus - */ - -enum _esxVI_ManagedEntityStatus { - esxVI_ManagedEntityStatus_Undefined = 0, - esxVI_ManagedEntityStatus_Gray, - esxVI_ManagedEntityStatus_Green, - esxVI_ManagedEntityStatus_Yellow, - esxVI_ManagedEntityStatus_Red, -}; - -int esxVI_ManagedEntityStatus_CastFromAnyType - (esxVI_AnyType *anyType, esxVI_ManagedEntityStatus *managedEntityStatus); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Enum: ObjectUpdateKind - */ - -enum _esxVI_ObjectUpdateKind { - esxVI_ObjectUpdateKind_Undefined = 0, - esxVI_ObjectUpdateKind_Enter, - esxVI_ObjectUpdateKind_Leave, - esxVI_ObjectUpdateKind_Modify, -}; - -int esxVI_ObjectUpdateKind_Deserialize - (xmlNodePtr node, esxVI_ObjectUpdateKind *objectUpdateKind); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Enum: PerfSummaryType - */ - -enum _esxVI_PerfSummaryType { - esxVI_PerfSummaryType_Undefined = 0, - esxVI_PerfSummaryType_Average, - esxVI_PerfSummaryType_Latest, - esxVI_PerfSummaryType_Maximum, - esxVI_PerfSummaryType_Minimum, - esxVI_PerfSummaryType_None, - esxVI_PerfSummaryType_Summation, -}; - -int esxVI_PerfSummaryType_Deserialize(xmlNodePtr node, - esxVI_PerfSummaryType *perfSummaryType); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Enum: PerfStatsType - */ - -enum _esxVI_PerfStatsType { - esxVI_PerfStatsType_Undefined = 0, - esxVI_PerfStatsType_Absolute, - esxVI_PerfStatsType_Delta, - esxVI_PerfStatsType_Rate, -}; - -int esxVI_PerfStatsType_Deserialize(xmlNodePtr node, - esxVI_PerfStatsType *perfStatsType); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Enum: PropertyChangeOp - */ - -enum _esxVI_PropertyChangeOp { - esxVI_PropertyChangeOp_Undefined = 0, - esxVI_PropertyChangeOp_Add, - esxVI_PropertyChangeOp_Remove, - esxVI_PropertyChangeOp_Assign, - esxVI_PropertyChangeOp_IndirectRemove, -}; - -int esxVI_PropertyChangeOp_Deserialize - (xmlNodePtr node, esxVI_PropertyChangeOp *propertyChangeOp); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Enum: SharesLevel - */ - -enum _esxVI_SharesLevel { - esxVI_SharesLevel_Undefined = 0, - esxVI_SharesLevel_Custom, - esxVI_SharesLevel_High, - esxVI_SharesLevel_Low, - esxVI_SharesLevel_Normal, -}; - -int esxVI_SharesLevel_Serialize(esxVI_SharesLevel sharesLevel, - const char *element, virBufferPtr output); -int esxVI_SharesLevel_Deserialize(xmlNodePtr node, - esxVI_SharesLevel *sharesLevel); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Enum: TaskInfoState - */ - -enum _esxVI_TaskInfoState { - esxVI_TaskInfoState_Undefined = 0, - esxVI_TaskInfoState_Error, - esxVI_TaskInfoState_Queued, - esxVI_TaskInfoState_Running, - esxVI_TaskInfoState_Success, -}; - -int esxVI_TaskInfoState_CastFromAnyType(esxVI_AnyType *anyType, - esxVI_TaskInfoState *taskInfoState); -int esxVI_TaskInfoState_Deserialize(xmlNodePtr node, - esxVI_TaskInfoState *taskInfoState); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Enum: VirtualMachineMovePriority - */ - -enum _esxVI_VirtualMachineMovePriority { - esxVI_VirtualMachineMovePriority_Undefined = 0, - esxVI_VirtualMachineMovePriority_LowPriority, - esxVI_VirtualMachineMovePriority_HighPriority, - esxVI_VirtualMachineMovePriority_DefaultPriority, -}; - -int esxVI_VirtualMachineMovePriority_Serialize - (esxVI_VirtualMachineMovePriority virtualMachineMovePriority, - const char *element, virBufferPtr output); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Enum: VirtualMachinePowerState - */ - -enum _esxVI_VirtualMachinePowerState { - esxVI_VirtualMachinePowerState_Undefined = 0, - esxVI_VirtualMachinePowerState_PoweredOff, - esxVI_VirtualMachinePowerState_PoweredOn, - esxVI_VirtualMachinePowerState_Suspended, -}; - -int esxVI_VirtualMachinePowerState_CastFromAnyType - (esxVI_AnyType *anyType, - esxVI_VirtualMachinePowerState *virtualMachinePowerState); -int esxVI_VirtualMachinePowerState_Serialize - (esxVI_VirtualMachinePowerState virtualMachinePowerState, - const char *element, virBufferPtr output); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * VI Type: Fault */ struct _esxVI_Fault { + esxVI_Fault *_unused; /* optional */ + esxVI_Type _type; /* required */ + char *faultcode; /* required */ char *faultstring; /* required */ }; @@ -440,6 +262,7 @@ int esxVI_Fault_Deserialize(xmlNodePtr node, esxVI_Fault **fault); struct _esxVI_ManagedObjectReference { esxVI_ManagedObjectReference *_next; /* optional */ + esxVI_Type _type; /* required */ char *type; /* required */ char *value; /* required */ @@ -454,14 +277,12 @@ int esxVI_ManagedObjectReference_DeepCopy(esxVI_ManagedObjectReference **dest, int esxVI_ManagedObjectReference_AppendToList (esxVI_ManagedObjectReference **managedObjectReferenceList, esxVI_ManagedObjectReference *managedObjectReference); -int esxVI_ManagedObjectReference_CastFromAnyType(esxVI_AnyType *anyType, - esxVI_ManagedObjectReference - **managedObjectReference, - const char *expectedType); +int esxVI_ManagedObjectReference_CastFromAnyType + (esxVI_AnyType *anyType, + esxVI_ManagedObjectReference **managedObjectReference); int esxVI_ManagedObjectReference_CastListFromAnyType (esxVI_AnyType *anyType, - esxVI_ManagedObjectReference **managedObjectReferenceList, - const char *expectedType); + esxVI_ManagedObjectReference **managedObjectReferenceList); int esxVI_ManagedObjectReference_Serialize (esxVI_ManagedObjectReference *managedObjectReference, const char *element, virBufferPtr output); @@ -469,833 +290,10 @@ int esxVI_ManagedObjectReference_SerializeList (esxVI_ManagedObjectReference *managedObjectReference, const char *element, virBufferPtr output); int esxVI_ManagedObjectReference_Deserialize - (xmlNodePtr node, esxVI_ManagedObjectReference **managedObjectReference, - const char *expectedType); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: DynamicProperty - */ - -struct _esxVI_DynamicProperty { - esxVI_DynamicProperty *_next; /* optional */ - - char *name; /* required */ - esxVI_AnyType *val; /* required */ -}; - -int esxVI_DynamicProperty_Alloc(esxVI_DynamicProperty **dynamicProperty); -void esxVI_DynamicProperty_Free - (esxVI_DynamicProperty **dynamicPropertyList); -int esxVI_DynamicProperty_Validate(esxVI_DynamicProperty *dynamicProperty); -int esxVI_DynamicProperty_DeepCopy(esxVI_DynamicProperty **dest, - esxVI_DynamicProperty *src); -int esxVI_DynamicProperty_DeepCopyList(esxVI_DynamicProperty **destList, - esxVI_DynamicProperty *srcList); -int esxVI_DynamicProperty_AppendToList - (esxVI_DynamicProperty **dynamicPropertyList, - esxVI_DynamicProperty *dynamicProperty); -int esxVI_DynamicProperty_Deserialize(xmlNodePtr node, - esxVI_DynamicProperty **dynamicProperty); -int esxVI_DynamicProperty_DeserializeList - (xmlNodePtr node, esxVI_DynamicProperty **dynamicPropertyList); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: HostCpuIdInfo - */ - -struct _esxVI_HostCpuIdInfo { - esxVI_HostCpuIdInfo *_next; /* optional */ - - esxVI_Int *level; /* required */ - char *vendor; /* optional */ - char *eax; /* optional */ - char *ebx; /* optional */ - char *ecx; /* optional */ - char *edx; /* optional */ -}; - -int esxVI_HostCpuIdInfo_Alloc(esxVI_HostCpuIdInfo **hostCpuIdInfo); -void esxVI_HostCpuIdInfo_Free(esxVI_HostCpuIdInfo **hostCpuIdInfoList); -int esxVI_HostCpuIdInfo_Validate(esxVI_HostCpuIdInfo *hostCpuIdInfo); -int esxVI_HostCpuIdInfo_CastFromAnyType(esxVI_AnyType *anyType, - esxVI_HostCpuIdInfo **hostCpuIdInfo); -int esxVI_HostCpuIdInfo_CastListFromAnyType - (esxVI_AnyType *anyType, esxVI_HostCpuIdInfo **hostCpuIdInfoList); -int esxVI_HostCpuIdInfo_Deserialize(xmlNodePtr node, - esxVI_HostCpuIdInfo **hostCpuIdInfo); -int esxVI_HostCpuIdInfo_DeserializeList - (xmlNodePtr node, esxVI_HostCpuIdInfo **hostCpuIdInfoList); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: SelectionSpec - */ - -struct _esxVI_SelectionSpec { - esxVI_SelectionSpec *_next; /* optional */ - esxVI_TraversalSpec *_super; /* optional */ - - char *name; /* optional */ -}; - -int esxVI_SelectionSpec_Alloc(esxVI_SelectionSpec **selectionSpec); -void esxVI_SelectionSpec_Free(esxVI_SelectionSpec **selectionSpecList); -int esxVI_SelectionSpec_Validate(esxVI_SelectionSpec *selectionSpec); -int esxVI_SelectionSpec_AppendToList(esxVI_SelectionSpec **selectionSpecList, - esxVI_SelectionSpec *selectionSpec); -int esxVI_SelectionSpec_Serialize(esxVI_SelectionSpec *selectionSpec, - const char *element, virBufferPtr output); -int esxVI_SelectionSpec_SerializeList(esxVI_SelectionSpec *selectionSpecList, - const char *element, virBufferPtr output); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: TraversalSpec extends SelectionSpec - */ - -struct _esxVI_TraversalSpec { - esxVI_SelectionSpec *_base; /* required */ - - char *type; /* required */ - char *path; /* required */ - esxVI_Boolean skip; /* optional */ - esxVI_SelectionSpec *selectSet; /* optional, list */ -}; - -int esxVI_TraversalSpec_Alloc(esxVI_TraversalSpec **traversalSpec); -void esxVI_TraversalSpec_Free(esxVI_TraversalSpec **traversalSpec); -int esxVI_TraversalSpec_Validate(esxVI_TraversalSpec *traversalSpec); -int esxVI_TraversalSpec_Serialize(esxVI_TraversalSpec *traversalSpec, - const char *element, virBufferPtr output); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: ObjectSpec - */ - -struct _esxVI_ObjectSpec { - esxVI_ObjectSpec *_next; /* optional */ - - esxVI_ManagedObjectReference *obj; /* required */ - esxVI_Boolean skip; /* optional */ - esxVI_SelectionSpec *selectSet; /* optional, list */ -}; - -int esxVI_ObjectSpec_Alloc(esxVI_ObjectSpec **objectSpec); -void esxVI_ObjectSpec_Free(esxVI_ObjectSpec **objectSpecList); -int esxVI_ObjectSpec_Validate(esxVI_ObjectSpec *objectSpec); -int esxVI_ObjectSpec_AppendToList(esxVI_ObjectSpec **objectSpecList, - esxVI_ObjectSpec *objectSpec); -int esxVI_ObjectSpec_Serialize(esxVI_ObjectSpec *objectSpec, - const char *element, virBufferPtr output); -int esxVI_ObjectSpec_SerializeList(esxVI_ObjectSpec *objectSpecList, - const char *element, virBufferPtr output); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: PropertyChange - */ - -struct _esxVI_PropertyChange { - esxVI_PropertyChange *_next; /* optional */ - - char *name; /* required */ - esxVI_PropertyChangeOp op; /* required */ - esxVI_AnyType *val; /* optional */ -}; - -int esxVI_PropertyChange_Alloc(esxVI_PropertyChange **propertyChange); -void esxVI_PropertyChange_Free(esxVI_PropertyChange **propertyChangeList); -int esxVI_PropertyChange_Validate(esxVI_PropertyChange *propertyChange); -int esxVI_PropertyChange_AppendToList - (esxVI_PropertyChange **propertyChangeList, - esxVI_PropertyChange *propertyChange); -int esxVI_PropertyChange_Deserialize(xmlNodePtr node, - esxVI_PropertyChange **propertyChange); -int esxVI_PropertyChange_DeserializeList - (xmlNodePtr node, esxVI_PropertyChange **propertyChangeList); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: PropertySpec - */ - -struct _esxVI_PropertySpec { - esxVI_PropertySpec *_next; /* optional */ - - char *type; /* required */ - esxVI_Boolean all; /* optional */ - esxVI_String *pathSet; /* optional, list */ -}; - -int esxVI_PropertySpec_Alloc(esxVI_PropertySpec **propertySpec); -void esxVI_PropertySpec_Free(esxVI_PropertySpec **propertySpecList); -int esxVI_PropertySpec_Validate(esxVI_PropertySpec *propertySpec); -int esxVI_PropertySpec_AppendToList(esxVI_PropertySpec **propertySpecList, - esxVI_PropertySpec *propertySpec); -int esxVI_PropertySpec_Serialize(esxVI_PropertySpec *propertySpec, - const char *element, virBufferPtr output); -int esxVI_PropertySpec_SerializeList(esxVI_PropertySpec *propertySpecList, - const char *element, virBufferPtr output); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: PropertyFilterSpec - */ - -struct _esxVI_PropertyFilterSpec { - esxVI_PropertyFilterSpec *_next; /* optional */ - - esxVI_PropertySpec *propSet; /* required, list */ - esxVI_ObjectSpec *objectSet; /* required, list */ -}; - -int esxVI_PropertyFilterSpec_Alloc - (esxVI_PropertyFilterSpec **propertyFilterSpec); -void esxVI_PropertyFilterSpec_Free - (esxVI_PropertyFilterSpec **propertyFilterSpecList); -int esxVI_PropertyFilterSpec_Validate - (esxVI_PropertyFilterSpec *propertyFilterSpec); -int esxVI_PropertyFilterSpec_AppendToList - (esxVI_PropertyFilterSpec **propertyFilterSpecList, - esxVI_PropertyFilterSpec *propertyFilterSpec); -int esxVI_PropertyFilterSpec_Serialize - (esxVI_PropertyFilterSpec *propertyFilterSpec, const char *element, - virBufferPtr output); -int esxVI_PropertyFilterSpec_SerializeList - (esxVI_PropertyFilterSpec *propertyFilterSpecList, const char *element, - virBufferPtr output); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: ObjectContent - */ - -struct _esxVI_ObjectContent { - esxVI_ObjectContent *_next; /* optional */ - - esxVI_ManagedObjectReference *obj; /* required */ - esxVI_DynamicProperty *propSet; /* optional, list */ - /*esxVI_MissingProperty *missingSet; *//* optional, list *//* FIXME */ -}; - -int esxVI_ObjectContent_Alloc(esxVI_ObjectContent **objectContent); -void esxVI_ObjectContent_Free(esxVI_ObjectContent **objectContentList); -int esxVI_ObjectContent_Validate(esxVI_ObjectContent *objectContent); -int esxVI_ObjectContent_AppendToList(esxVI_ObjectContent **objectContentList, - esxVI_ObjectContent *objectContent); -int esxVI_ObjectContent_DeepCopy(esxVI_ObjectContent **dest, - esxVI_ObjectContent *src); -int esxVI_ObjectContent_Deserialize(xmlNodePtr node, - esxVI_ObjectContent **objectContent); -int esxVI_ObjectContent_DeserializeList - (xmlNodePtr node, esxVI_ObjectContent **objectContentList); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: ObjectUpdate - */ - -struct _esxVI_ObjectUpdate { - esxVI_ObjectUpdate *_next; /* optional */ - - esxVI_ObjectUpdateKind kind; /* required */ - esxVI_ManagedObjectReference *obj; /* required */ - esxVI_PropertyChange *changeSet; /* optional, list */ - /*esxVI_MissingProperty *missingSet; *//* optional, list *//* FIXME */ -}; - -int esxVI_ObjectUpdate_Alloc(esxVI_ObjectUpdate **objectUpdate); -void esxVI_ObjectUpdate_Free(esxVI_ObjectUpdate **objectUpdateList); -int esxVI_ObjectUpdate_Validate(esxVI_ObjectUpdate *objectUpdate); -int esxVI_ObjectUpdate_AppendToList(esxVI_ObjectUpdate **objectUpdateList, - esxVI_ObjectUpdate *objectUpdate); -int esxVI_ObjectUpdate_Deserialize(xmlNodePtr node, - esxVI_ObjectUpdate **objectUpdate); -int esxVI_ObjectUpdate_DeserializeList(xmlNodePtr node, - esxVI_ObjectUpdate **objectUpdateList); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: PropertyFilterUpdate - */ - -struct _esxVI_PropertyFilterUpdate { - esxVI_PropertyFilterUpdate *_next; /* optional */ - - esxVI_ManagedObjectReference *filter; /* required */ - esxVI_ObjectUpdate *objectSet; /* optional, list */ - /*esxVI_MissingProperty *missingSet; *//* optional, list *//* FIXME */ -}; - -int esxVI_PropertyFilterUpdate_Alloc - (esxVI_PropertyFilterUpdate **propertyFilterUpdate); -void esxVI_PropertyFilterUpdate_Free - (esxVI_PropertyFilterUpdate **propertyFilterUpdateList); -int esxVI_PropertyFilterUpdate_Validate - (esxVI_PropertyFilterUpdate *propertyFilterUpdate); -int esxVI_PropertyFilterUpdate_AppendToList - (esxVI_PropertyFilterUpdate **propertyFilterUpdateList, - esxVI_PropertyFilterUpdate *propertyFilterUpdate); -int esxVI_PropertyFilterUpdate_Deserialize - (xmlNodePtr node, esxVI_PropertyFilterUpdate **propertyFilterUpdate); -int esxVI_PropertyFilterUpdate_DeserializeList - (xmlNodePtr node, esxVI_PropertyFilterUpdate **propertyFilterUpdateList); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: AboutInfo - */ - -struct _esxVI_AboutInfo { - char *name; /* required */ - char *fullName; /* required */ - char *vendor; /* required */ - char *version; /* required */ - char *build; /* required */ - char *localeVersion; /* optional */ - char *localeBuild; /* optional */ - char *osType; /* required */ - char *productLineId; /* required */ - char *apiType; /* required */ - char *apiVersion; /* required */ -}; - -int esxVI_AboutInfo_Alloc(esxVI_AboutInfo **aboutInfo); -void esxVI_AboutInfo_Free(esxVI_AboutInfo **aboutInfo); -int esxVI_AboutInfo_Validate(esxVI_AboutInfo *aboutInfo); -int esxVI_AboutInfo_Deserialize(xmlNodePtr node, esxVI_AboutInfo **aboutInfo); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: ServiceContent - */ - -struct _esxVI_ServiceContent { - esxVI_ManagedObjectReference *rootFolder; /* required */ - esxVI_ManagedObjectReference *propertyCollector; /* required */ - esxVI_ManagedObjectReference *viewManager; /* optional */ - esxVI_AboutInfo *about; /* required */ - esxVI_ManagedObjectReference *setting; /* optional */ - esxVI_ManagedObjectReference *userDirectory; /* optional */ - esxVI_ManagedObjectReference *sessionManager; /* optional */ - esxVI_ManagedObjectReference *authorizationManager; /* optional */ - esxVI_ManagedObjectReference *perfManager; /* optional */ - esxVI_ManagedObjectReference *scheduledTaskManager; /* optional */ - esxVI_ManagedObjectReference *alarmManager; /* optional */ - esxVI_ManagedObjectReference *eventManager; /* optional */ - esxVI_ManagedObjectReference *taskManager; /* optional */ - esxVI_ManagedObjectReference *extensionManager; /* optional */ - esxVI_ManagedObjectReference *customizationSpecManager; /* optional */ - esxVI_ManagedObjectReference *customFieldsManager; /* optional */ - esxVI_ManagedObjectReference *accountManager; /* optional */ - esxVI_ManagedObjectReference *diagnosticManager; /* optional */ - esxVI_ManagedObjectReference *licenseManager; /* optional */ - esxVI_ManagedObjectReference *searchIndex; /* optional */ - esxVI_ManagedObjectReference *fileManager; /* optional */ - esxVI_ManagedObjectReference *virtualDiskManager; /* optional */ - esxVI_ManagedObjectReference *virtualizationManager; /* optional */ -}; - -int esxVI_ServiceContent_Alloc(esxVI_ServiceContent **serviceContent); -void esxVI_ServiceContent_Free(esxVI_ServiceContent **serviceContent); -int esxVI_ServiceContent_Validate(esxVI_ServiceContent *serviceContent); -int esxVI_ServiceContent_Deserialize(xmlNodePtr node, - esxVI_ServiceContent **serviceContent); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: UpdateSet - */ - -struct _esxVI_UpdateSet { - char *version; /* required */ - esxVI_PropertyFilterUpdate *filterSet; /* optional, list */ -}; - -int esxVI_UpdateSet_Alloc(esxVI_UpdateSet **updateSet); -void esxVI_UpdateSet_Free(esxVI_UpdateSet **updateSet); -int esxVI_UpdateSet_Validate(esxVI_UpdateSet *updateSet); -int esxVI_UpdateSet_Deserialize(xmlNodePtr node, esxVI_UpdateSet **updateSet); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: SharesInfo - */ - -struct _esxVI_SharesInfo { - esxVI_Int *shares; /* required */ - esxVI_SharesLevel level; /* required */ -}; - -int esxVI_SharesInfo_Alloc(esxVI_SharesInfo **sharesInfo); -void esxVI_SharesInfo_Free(esxVI_SharesInfo **sharesInfo); -int esxVI_SharesInfo_Validate(esxVI_SharesInfo *sharesInfo); -int esxVI_SharesInfo_CastFromAnyType(esxVI_AnyType *anyType, - esxVI_SharesInfo **sharesInfo); -int esxVI_SharesInfo_Deserialize(xmlNodePtr node, - esxVI_SharesInfo **sharesInfo); -int esxVI_SharesInfo_Serialize(esxVI_SharesInfo *sharesInfo, - const char *element, virBufferPtr output); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: ResourceAllocationInfo - */ - -struct _esxVI_ResourceAllocationInfo { - esxVI_Long *reservation; /* optional */ - esxVI_Boolean expandableReservation; /* optional */ - esxVI_Long *limit; /* optional */ - esxVI_SharesInfo *shares; /* optional */ - esxVI_Long *overheadLimit; /* optional */ -}; - -int esxVI_ResourceAllocationInfo_Alloc - (esxVI_ResourceAllocationInfo **resourceAllocationInfo); -void esxVI_ResourceAllocationInfo_Free - (esxVI_ResourceAllocationInfo **resourceAllocationInfo); -int esxVI_ResourceAllocationInfo_Validate - (esxVI_ResourceAllocationInfo *resourceAllocationInfo); -int esxVI_ResourceAllocationInfo_Serialize - (esxVI_ResourceAllocationInfo *resourceAllocationInfo, - const char *element, virBufferPtr output); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: ResourcePoolResourceUsage - */ - -struct _esxVI_ResourcePoolResourceUsage { - esxVI_Long *reservationUsed; /* required */ - esxVI_Long *reservationUsedForVm; /* required */ - esxVI_Long *unreservedForPool; /* required */ - esxVI_Long *unreservedForVm; /* required */ - esxVI_Long *overallUsage; /* required */ - esxVI_Long *maxUsage; /* required */ -}; - -int esxVI_ResourcePoolResourceUsage_Alloc - (esxVI_ResourcePoolResourceUsage **resourcePoolResourceUsage); -void esxVI_ResourcePoolResourceUsage_Free - (esxVI_ResourcePoolResourceUsage **resourcePoolResourceUsage); -int esxVI_ResourcePoolResourceUsage_Validate - (esxVI_ResourcePoolResourceUsage *resourcePoolResourceUsage); -int esxVI_ResourcePoolResourceUsage_CastFromAnyType - (esxVI_AnyType *anyType, - esxVI_ResourcePoolResourceUsage **resourcePoolResourceUsage); -int esxVI_ResourcePoolResourceUsage_Deserialize - (xmlNodePtr node, - esxVI_ResourcePoolResourceUsage **resourcePoolResourceUsage); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: VirtualMachineConfigSpec - */ - -/* FIXME: implement the rest */ -struct _esxVI_VirtualMachineConfigSpec { - char *changeVersion; /* optional */ - char *name; /* optional */ - char *version; /* optional */ - char *uuid; /* optional */ - esxVI_Long *npivNodeWorldWideName; /* optional, list */ - esxVI_Long *npivPortWorldWideName; /* optional, list */ - char *npivWorldWideNameType; /* optional */ - char *npivWorldWideNameOp; /* optional */ - char *locationId; /* optional */ - char *guestId; /* optional */ - char *alternateGuestName; /* optional */ - char *annotation; /* optional */ - //esxVI_VirtualMachineFileInfo *files; /* optional */ - //esxVI_ToolsConfigInfo *tools; /* optional */ - //esxVI_VirtualMachineFlagInfo *flags; /* optional */ - //esxVI_VirtualMachineConsolePreferences *consolePreferences; /* optional */ - //esxVI_VirtualMachineDefaultPowerOpInfo *powerOpInfo; /* optional */ - esxVI_Int *numCPUs; /* optional */ - esxVI_Long *memoryMB; /* optional */ - //esxVI_VirtualDeviceConfigSpec *deviceChange; /* optional, list */ - esxVI_ResourceAllocationInfo *cpuAllocation; /* optional */ - esxVI_ResourceAllocationInfo *memoryAllocation; /* optional */ - //esxVI_VirtualMachineAffinityInfo *cpuAffinity; /* optional */ - //esxVI_VirtualMachineAffinityInfo *memoryAffinity; /* optional */ - //esxVI_VirtualMachineNetworkShaperInfo *networkShaper; /* optional */ - //esxVI_VirtualMachineCpuIdInfoSpec *cpuFeatureMask; /* optional, list */ - //esxVI_OptionValue *extraConfig; /* optional, list */ - char *swapPlacement; /* optional */ - //esxVI_VirtualMachineBootOptions *bootOptions; /* optional */ -}; - -int esxVI_VirtualMachineConfigSpec_Alloc - (esxVI_VirtualMachineConfigSpec **virtualMachineConfigSpec); -void esxVI_VirtualMachineConfigSpec_Free - (esxVI_VirtualMachineConfigSpec **virtualMachineConfigSpec); -int esxVI_VirtualMachineConfigSpec_Validate - (esxVI_VirtualMachineConfigSpec *virtualMachineConfigSpec); -int esxVI_VirtualMachineConfigSpec_Serialize - (esxVI_VirtualMachineConfigSpec *virtualMachineConfigSpec, - const char *element, virBufferPtr output); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: Event - */ - -/* FIXME: implement the rest */ -struct _esxVI_Event { - esxVI_Event *_next; /* optional */ - - esxVI_Int *key; /* required */ - esxVI_Int *chainId; /* required */ - esxVI_DateTime *createdTime; /* required */ - char *userName; /* required */ - //??? datacenter; /* optional */ - //??? computeResource; /* optional */ - //??? host; /* optional */ - //??? vm; /* optional */ - char *fullFormattedMessage; /* optional */ -}; - -int esxVI_Event_Alloc(esxVI_Event **event); -void esxVI_Event_Free(esxVI_Event **eventList); -int esxVI_Event_Validate(esxVI_Event *event); -int esxVI_Event_Deserialize(xmlNodePtr node, esxVI_Event **event); -int esxVI_Event_DeserializeList(xmlNodePtr node, esxVI_Event **eventList); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: UserSession - */ - -struct _esxVI_UserSession { - char *key; /* required */ - char *userName; /* required */ - char *fullName; /* required */ - esxVI_DateTime *loginTime; /* required */ - esxVI_DateTime *lastActiveTime; /* required */ - char *locale; /* required */ - char *messageLocale; /* required */ -}; - -int esxVI_UserSession_Alloc(esxVI_UserSession **userSession); -void esxVI_UserSession_Free(esxVI_UserSession **userSession); -int esxVI_UserSession_Validate(esxVI_UserSession *userSession); -int esxVI_UserSession_CastFromAnyType(esxVI_AnyType *anyType, - esxVI_UserSession **userSession); -int esxVI_UserSession_Deserialize(xmlNodePtr node, - esxVI_UserSession **userSession); - + (xmlNodePtr node, esxVI_ManagedObjectReference **managedObjectReference); -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: VirtualMachineQuestionInfo - */ - -/* FIXME: implement the rest */ -struct _esxVI_VirtualMachineQuestionInfo { - char *id; /* required */ - char *text; /* required */ - esxVI_ChoiceOption *choice; /* required */ - /*esxVI_VirtualMachineMessage *message;*/ /* optional, list */ -}; - -int esxVI_VirtualMachineQuestionInfo_Alloc - (esxVI_VirtualMachineQuestionInfo **virtualMachineQuestionInfo); -void esxVI_VirtualMachineQuestionInfo_Free - (esxVI_VirtualMachineQuestionInfo **virtualMachineQuestionInfo); -int esxVI_VirtualMachineQuestionInfo_Validate - (esxVI_VirtualMachineQuestionInfo *virtualMachineQuestionInfo); -int esxVI_VirtualMachineQuestionInfo_CastFromAnyType - (esxVI_AnyType *anyType, - esxVI_VirtualMachineQuestionInfo **virtualMachineQuestionInfo); -int esxVI_VirtualMachineQuestionInfo_Deserialize - (xmlNodePtr node, - esxVI_VirtualMachineQuestionInfo **virtualMachineQuestionInfo); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: ElementDescription extends Description - * - * In contrast to SelectionSpec and TraversalSpec just merge - * Description into ElementDescription for simplicity, because - * only ElementDescription is used. - */ - -struct _esxVI_ElementDescription { - esxVI_ElementDescription *_next; /* optional */ - - /* Description */ - char *label; /* required */ - char *summary; /* required */ - - /* ElementDescription */ - char *key; /* required */ -}; - -int esxVI_ElementDescription_Alloc - (esxVI_ElementDescription **elementDescription); -void esxVI_ElementDescription_Free - (esxVI_ElementDescription **elementDescription); -int esxVI_ElementDescription_Validate - (esxVI_ElementDescription *elementDescription); -int esxVI_ElementDescription_AppendToList - (esxVI_ElementDescription **elementDescriptionList, - esxVI_ElementDescription *elementDescription); -int esxVI_ElementDescription_Deserialize - (xmlNodePtr node, esxVI_ElementDescription **elementDescription); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: ChoiceOption extends OptionType - * - * In contrast to SelectionSpec and TraversalSpec just merge - * OptionType into ChoiceOption for simplicity, because - * only ChoiceOption is used. - */ - -struct _esxVI_ChoiceOption { - /* OptionType */ - esxVI_Boolean valueIsReadonly; /* optional */ - - /* ChoiceOption */ - esxVI_ElementDescription *choiceInfo; /* required, list */ - esxVI_Int *defaultIndex; /* optional */ -}; - -int esxVI_ChoiceOption_Alloc(esxVI_ChoiceOption **choiceOption); -void esxVI_ChoiceOption_Free(esxVI_ChoiceOption **choiceOption); -int esxVI_ChoiceOption_Validate(esxVI_ChoiceOption *choiceOption); -int esxVI_ChoiceOption_Deserialize(xmlNodePtr node, - esxVI_ChoiceOption **choiceOption); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: PerfMetricId - */ - -struct _esxVI_PerfMetricId { - esxVI_PerfMetricId *_next; /* optional */ - - esxVI_Int *counterId; /* required */ - char *instance; /* required */ -}; - -int esxVI_PerfMetricId_Alloc(esxVI_PerfMetricId **perfMetricId); -void esxVI_PerfMetricId_Free(esxVI_PerfMetricId **perfMetricId); -int esxVI_PerfMetricId_Validate(esxVI_PerfMetricId *perfMetricId); -int esxVI_PerfMetricId_Serialize(esxVI_PerfMetricId *perfMetricId, - const char *element, virBufferPtr output); -int esxVI_PerfMetricId_SerializeList(esxVI_PerfMetricId *perfMetricIdList, - const char *element, virBufferPtr output); -int esxVI_PerfMetricId_Deserialize(xmlNodePtr node, - esxVI_PerfMetricId **perfMetricId); -int esxVI_PerfMetricId_DeserializeList(xmlNodePtr node, - esxVI_PerfMetricId **perfMetricIdList); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: PerfCounterInfo - */ - -struct _esxVI_PerfCounterInfo { - esxVI_PerfCounterInfo *_next; /* optional */ - - esxVI_Int *key; /* required */ - esxVI_ElementDescription *nameInfo; /* required */ - esxVI_ElementDescription *groupInfo; /* required */ - esxVI_ElementDescription *unitInfo; /* required */ - esxVI_PerfSummaryType rollupType; /* required */ - esxVI_PerfStatsType statsType; /* required */ - esxVI_Int *level; /* optional */ - esxVI_Int *associatedCounterId; /* optional, list */ -}; - -int esxVI_PerfCounterInfo_Alloc(esxVI_PerfCounterInfo **perfCounterInfo); -void esxVI_PerfCounterInfo_Free(esxVI_PerfCounterInfo **perfCounterInfo); -int esxVI_PerfCounterInfo_Validate(esxVI_PerfCounterInfo *perfCounterInfo); -int esxVI_PerfCounterInfo_Deserialize(xmlNodePtr node, - esxVI_PerfCounterInfo **perfCounterInfo); -int esxVI_PerfCounterInfo_DeserializeList - (xmlNodePtr node, esxVI_PerfCounterInfo **perfCounterInfoList); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: PerfQuerySpec - */ - -struct _esxVI_PerfQuerySpec { - esxVI_PerfQuerySpec *_next; /* optional */ - - esxVI_ManagedObjectReference *entity; /* required */ - esxVI_DateTime *startTime; /* optional */ - esxVI_DateTime *endTime; /* optional */ - esxVI_Int *maxSample; /* optional */ - esxVI_PerfMetricId *metricId; /* optional, list */ - esxVI_Int *intervalId; /* optional */ - char *format; /* optional */ // FIXME: see PerfFormat -}; - -int esxVI_PerfQuerySpec_Alloc(esxVI_PerfQuerySpec **perfQuerySpec); -void esxVI_PerfQuerySpec_Free(esxVI_PerfQuerySpec **perfQuerySpec); -int esxVI_PerfQuerySpec_Validate(esxVI_PerfQuerySpec *perfQuerySpec); -int esxVI_PerfQuerySpec_Serialize(esxVI_PerfQuerySpec *perfQuerySpec, - const char *element, virBufferPtr output); -int esxVI_PerfQuerySpec_SerializeList(esxVI_PerfQuerySpec *perfQuerySpecList, - const char *element, virBufferPtr output); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: PerfSampleInfo - */ - -struct _esxVI_PerfSampleInfo { - esxVI_PerfSampleInfo *_next; /* optional */ - - esxVI_DateTime *timestamp; /* required */ - esxVI_Int *interval; /* required */ -}; - -int esxVI_PerfSampleInfo_Alloc(esxVI_PerfSampleInfo **perfSampleInfo); -void esxVI_PerfSampleInfo_Free(esxVI_PerfSampleInfo **perfSampleInfo); -int esxVI_PerfSampleInfo_Validate(esxVI_PerfSampleInfo *perfSampleInfo); -int esxVI_PerfSampleInfo_AppendToList(esxVI_PerfSampleInfo **perfSampleInfoList, - esxVI_PerfSampleInfo *perfSampleInfo); -int esxVI_PerfSampleInfo_Deserialize(xmlNodePtr node, - esxVI_PerfSampleInfo **perfSampleInfo); -int esxVI_PerfSampleInfo_DeserializeList - (xmlNodePtr node, esxVI_PerfSampleInfo **perfSampleInfoList); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: PerfMetricIntSeries extends PerfMetricSeries - * - * In contrast to SelectionSpec and TraversalSpec just merge - * PerfMetricSeries into PerfMetricIntSeries for simplicity, because - * only PerfMetricIntSeries is used and the other type inheriting - * PerfMetricSeries (PerfMetricSeriesCSV) is not used. - */ - -struct _esxVI_PerfMetricIntSeries { - esxVI_PerfMetricIntSeries *_next; /* optional */ - - /* PerfMetricSeries */ - esxVI_PerfMetricId *id; /* required */ - - /* PerfMetricIntSeries */ - esxVI_Long *value; /* optional, list */ -}; - -int esxVI_PerfMetricIntSeries_Alloc - (esxVI_PerfMetricIntSeries **perfMetricIntSeries); -void esxVI_PerfMetricIntSeries_Free - (esxVI_PerfMetricIntSeries **perfMetricIntSeries); -int esxVI_PerfMetricIntSeries_Validate - (esxVI_PerfMetricIntSeries *perfMetricIntSeries); -int esxVI_PerfMetricIntSeries_AppendToList - (esxVI_PerfMetricIntSeries **perfMetricIntSeriesList, - esxVI_PerfMetricIntSeries *perfMetricIntSeries); -int esxVI_PerfMetricIntSeries_Deserialize - (xmlNodePtr node, esxVI_PerfMetricIntSeries **perfMetricIntSeries); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: PerfEntityMetric extends PerfEntityMetricBase - * - * In contrast to SelectionSpec and TraversalSpec just merge - * PerfEntityMetricBase into PerfEntityMetric for simplicity, because - * only PerfEntityMetric is used and the other type inheriting - * PerfEntityMetric (PerfEntityMetricCSV) is not used. - * - * Also use PerfMetricIntSeries instead of the correct base type - * PerfMetricSeries for the value property, because only - * PerfMetricIntSeries is used. - */ - -struct _esxVI_PerfEntityMetric { - esxVI_PerfEntityMetric *_next; /* optional */ - - /* PerfEntityMetricBase */ - esxVI_ManagedObjectReference *entity; /* required */ - - /* PerfEntityMetric */ - esxVI_PerfSampleInfo *sampleInfo; /* optional, list */ - esxVI_PerfMetricIntSeries *value; /* optional, list */ -}; - -int esxVI_PerfEntityMetric_Alloc(esxVI_PerfEntityMetric **perfEntityMetric); -void esxVI_PerfEntityMetric_Free(esxVI_PerfEntityMetric **perfEntityMetric); -int esxVI_PerfEntityMetric_Validate(esxVI_PerfEntityMetric *perfEntityMetric); -int esxVI_PerfEntityMetric_Deserialize - (xmlNodePtr node, esxVI_PerfEntityMetric **perfEntityMetric); -int esxVI_PerfEntityMetric_DeserializeList - (xmlNodePtr node, esxVI_PerfEntityMetric **perfEntityMetricList); - - - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * VI Type: TaskInfo - */ - -struct _esxVI_TaskInfo { - esxVI_TaskInfo *_next; /* optional */ - - char *key; /* required */ - esxVI_ManagedObjectReference *task; /* required */ - char *name; /* optional */ - char *descriptionId; /* required */ - esxVI_ManagedObjectReference *entity; /* optional */ - char *entityName; /* optional */ - /*esxVI_ManagedObjectReference *locked;*/ /* optional, list *//* FIXME */ - esxVI_TaskInfoState state; /* required */ - esxVI_Boolean cancelled; /* required */ - esxVI_Boolean cancelable; /* required */ - /*esxVI_MethodFault *error;*/ /* optional *//* FIXME */ - esxVI_AnyType *result; /* optional */ - esxVI_Int *progress; /* optional */ - /*esxVI_TaskReason *reason;*/ /* required *//* FIXME */ - esxVI_DateTime *queueTime; /* required */ - esxVI_DateTime *startTime; /* optional */ - esxVI_DateTime *completeTime; /* optional */ - esxVI_Int *eventChainId; /* required */ -}; -int esxVI_TaskInfo_Alloc(esxVI_TaskInfo **taskInfo); -void esxVI_TaskInfo_Free(esxVI_TaskInfo **taskInfoList); -int esxVI_TaskInfo_Validate(esxVI_TaskInfo *taskInfo); -int esxVI_TaskInfo_CastFromAnyType(esxVI_AnyType *anyType, - esxVI_TaskInfo **taskInfo); -int esxVI_TaskInfo_AppendToList(esxVI_TaskInfo **taskInfoList, - esxVI_TaskInfo *taskInfo); -int esxVI_TaskInfo_Deserialize(xmlNodePtr node, esxVI_TaskInfo **taskInfo); +#include "esx_vi_types.generated.h" #endif /* __ESX_VI_TYPES_H__ */ -- 1.6.3.3